/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
"use strict";

var $protobuf = window["protobuf"];

// Common aliases
var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;

// Exported root namespace
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});

$root.C2GS = (function() {

    /**
     * Properties of a C2GS.
     * @exports IC2GS
     * @interface IC2GS
     * @property {number|null} [session] C2GS session
     * @property {string|null} [protocolId] C2GS protocolId
     * @property {msg.login.IsdkUploadReq|null} [SdkUploadReq] C2GS SdkUploadReq
     * @property {msg.login.IloginReq|null} [LoginReq] C2GS LoginReq
     * @property {msg.action.IsyncMoneyReq|null} [SyncMoneyReq] C2GS SyncMoneyReq
     * @property {msg.action.IsyncPetMagicReq|null} [SyncPetMagicReq] C2GS SyncPetMagicReq
     * @property {msg.action.IactivePetMagicReq|null} [ActivePetMagicReq] C2GS ActivePetMagicReq
     * @property {msg.action.IrewardReq|null} [RewardReq] C2GS RewardReq
     * @property {msg.action.IgetTaskRewardReq|null} [GetTaskRewardReq] C2GS GetTaskRewardReq
     * @property {msg.action.IcashReq|null} [CashReq] C2GS CashReq
     * @property {msg.info.IplayerInfoReq|null} [PlayerInfoReq] C2GS PlayerInfoReq
     * @property {msg.notice.IadRecordReq|null} [AdRecordReq] C2GS AdRecordReq
     * @property {msg.notice.IadShowReq|null} [AdShowReq] C2GS AdShowReq
     * @property {msg.action.IplayerSetReq|null} [PlayerSetReq] C2GS PlayerSetReq
     * @property {msg.action.IclientLogReq|null} [ClientLogReq] C2GS ClientLogReq
     * @property {msg.action.IpassReq|null} [PassReq] C2GS PassReq
     * @property {msg.action.IrecycleLevelReq|null} [RecycleLevelReq] C2GS RecycleLevelReq
     * @property {string|null} [ctime] C2GS ctime
     * @property {string|null} [token] C2GS token
     */

    /**
     * Constructs a new C2GS.
     * @exports C2GS
     * @classdesc Represents a C2GS.
     * @implements IC2GS
     * @constructor
     * @param {IC2GS=} [properties] Properties to set
     */
    function C2GS(properties) {
        if (properties)
            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * C2GS session.
     * @member {number} session
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.session = 0;

    /**
     * C2GS protocolId.
     * @member {string} protocolId
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.protocolId = "";

    /**
     * C2GS SdkUploadReq.
     * @member {msg.login.IsdkUploadReq|null|undefined} SdkUploadReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.SdkUploadReq = null;

    /**
     * C2GS LoginReq.
     * @member {msg.login.IloginReq|null|undefined} LoginReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.LoginReq = null;

    /**
     * C2GS SyncMoneyReq.
     * @member {msg.action.IsyncMoneyReq|null|undefined} SyncMoneyReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.SyncMoneyReq = null;

    /**
     * C2GS SyncPetMagicReq.
     * @member {msg.action.IsyncPetMagicReq|null|undefined} SyncPetMagicReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.SyncPetMagicReq = null;

    /**
     * C2GS ActivePetMagicReq.
     * @member {msg.action.IactivePetMagicReq|null|undefined} ActivePetMagicReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.ActivePetMagicReq = null;

    /**
     * C2GS RewardReq.
     * @member {msg.action.IrewardReq|null|undefined} RewardReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.RewardReq = null;

    /**
     * C2GS GetTaskRewardReq.
     * @member {msg.action.IgetTaskRewardReq|null|undefined} GetTaskRewardReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.GetTaskRewardReq = null;

    /**
     * C2GS CashReq.
     * @member {msg.action.IcashReq|null|undefined} CashReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.CashReq = null;

    /**
     * C2GS PlayerInfoReq.
     * @member {msg.info.IplayerInfoReq|null|undefined} PlayerInfoReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.PlayerInfoReq = null;

    /**
     * C2GS AdRecordReq.
     * @member {msg.notice.IadRecordReq|null|undefined} AdRecordReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.AdRecordReq = null;

    /**
     * C2GS AdShowReq.
     * @member {msg.notice.IadShowReq|null|undefined} AdShowReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.AdShowReq = null;

    /**
     * C2GS PlayerSetReq.
     * @member {msg.action.IplayerSetReq|null|undefined} PlayerSetReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.PlayerSetReq = null;

    /**
     * C2GS ClientLogReq.
     * @member {msg.action.IclientLogReq|null|undefined} ClientLogReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.ClientLogReq = null;

    /**
     * C2GS PassReq.
     * @member {msg.action.IpassReq|null|undefined} PassReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.PassReq = null;

    /**
     * C2GS RecycleLevelReq.
     * @member {msg.action.IrecycleLevelReq|null|undefined} RecycleLevelReq
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.RecycleLevelReq = null;

    /**
     * C2GS ctime.
     * @member {string} ctime
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.ctime = "";

    /**
     * C2GS token.
     * @member {string} token
     * @memberof C2GS
     * @instance
     */
    C2GS.prototype.token = "";

    /**
     * Creates a new C2GS instance using the specified properties.
     * @function create
     * @memberof C2GS
     * @static
     * @param {IC2GS=} [properties] Properties to set
     * @returns {C2GS} C2GS instance
     */
    C2GS.create = function create(properties) {
        return new C2GS(properties);
    };

    /**
     * Encodes the specified C2GS message. Does not implicitly {@link C2GS.verify|verify} messages.
     * @function encode
     * @memberof C2GS
     * @static
     * @param {IC2GS} message C2GS message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    C2GS.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.session != null && Object.hasOwnProperty.call(message, "session"))
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.session);
        if (message.protocolId != null && Object.hasOwnProperty.call(message, "protocolId"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.protocolId);
        if (message.SdkUploadReq != null && Object.hasOwnProperty.call(message, "SdkUploadReq"))
            $root.msg.login.sdkUploadReq.encode(message.SdkUploadReq, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
        if (message.LoginReq != null && Object.hasOwnProperty.call(message, "LoginReq"))
            $root.msg.login.loginReq.encode(message.LoginReq, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        if (message.SyncMoneyReq != null && Object.hasOwnProperty.call(message, "SyncMoneyReq"))
            $root.msg.action.syncMoneyReq.encode(message.SyncMoneyReq, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
        if (message.SyncPetMagicReq != null && Object.hasOwnProperty.call(message, "SyncPetMagicReq"))
            $root.msg.action.syncPetMagicReq.encode(message.SyncPetMagicReq, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
        if (message.ActivePetMagicReq != null && Object.hasOwnProperty.call(message, "ActivePetMagicReq"))
            $root.msg.action.activePetMagicReq.encode(message.ActivePetMagicReq, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
        if (message.RewardReq != null && Object.hasOwnProperty.call(message, "RewardReq"))
            $root.msg.action.rewardReq.encode(message.RewardReq, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
        if (message.GetTaskRewardReq != null && Object.hasOwnProperty.call(message, "GetTaskRewardReq"))
            $root.msg.action.getTaskRewardReq.encode(message.GetTaskRewardReq, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
        if (message.CashReq != null && Object.hasOwnProperty.call(message, "CashReq"))
            $root.msg.action.cashReq.encode(message.CashReq, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
        if (message.PlayerInfoReq != null && Object.hasOwnProperty.call(message, "PlayerInfoReq"))
            $root.msg.info.playerInfoReq.encode(message.PlayerInfoReq, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
        if (message.AdRecordReq != null && Object.hasOwnProperty.call(message, "AdRecordReq"))
            $root.msg.notice.adRecordReq.encode(message.AdRecordReq, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
        if (message.AdShowReq != null && Object.hasOwnProperty.call(message, "AdShowReq"))
            $root.msg.notice.adShowReq.encode(message.AdShowReq, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
        if (message.PlayerSetReq != null && Object.hasOwnProperty.call(message, "PlayerSetReq"))
            $root.msg.action.playerSetReq.encode(message.PlayerSetReq, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
        if (message.ClientLogReq != null && Object.hasOwnProperty.call(message, "ClientLogReq"))
            $root.msg.action.clientLogReq.encode(message.ClientLogReq, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
        if (message.PassReq != null && Object.hasOwnProperty.call(message, "PassReq"))
            $root.msg.action.passReq.encode(message.PassReq, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
        if (message.RecycleLevelReq != null && Object.hasOwnProperty.call(message, "RecycleLevelReq"))
            $root.msg.action.recycleLevelReq.encode(message.RecycleLevelReq, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
        if (message.ctime != null && Object.hasOwnProperty.call(message, "ctime"))
            writer.uint32(/* id 18, wireType 2 =*/146).string(message.ctime);
        if (message.token != null && Object.hasOwnProperty.call(message, "token"))
            writer.uint32(/* id 19, wireType 2 =*/154).string(message.token);
        return writer;
    };

    /**
     * Encodes the specified C2GS message, length delimited. Does not implicitly {@link C2GS.verify|verify} messages.
     * @function encodeDelimited
     * @memberof C2GS
     * @static
     * @param {IC2GS} message C2GS message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    C2GS.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a C2GS message from the specified reader or buffer.
     * @function decode
     * @memberof C2GS
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {C2GS} C2GS
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    C2GS.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.C2GS();
        while (reader.pos < end) {
            var tag = reader.uint32();
            switch (tag >>> 3) {
            case 1:
                message.session = reader.int32();
                break;
            case 2:
                message.protocolId = reader.string();
                break;
            case 3:
                message.SdkUploadReq = $root.msg.login.sdkUploadReq.decode(reader, reader.uint32());
                break;
            case 4:
                message.LoginReq = $root.msg.login.loginReq.decode(reader, reader.uint32());
                break;
            case 5:
                message.SyncMoneyReq = $root.msg.action.syncMoneyReq.decode(reader, reader.uint32());
                break;
            case 6:
                message.SyncPetMagicReq = $root.msg.action.syncPetMagicReq.decode(reader, reader.uint32());
                break;
            case 7:
                message.ActivePetMagicReq = $root.msg.action.activePetMagicReq.decode(reader, reader.uint32());
                break;
            case 8:
                message.RewardReq = $root.msg.action.rewardReq.decode(reader, reader.uint32());
                break;
            case 9:
                message.GetTaskRewardReq = $root.msg.action.getTaskRewardReq.decode(reader, reader.uint32());
                break;
            case 10:
                message.CashReq = $root.msg.action.cashReq.decode(reader, reader.uint32());
                break;
            case 11:
                message.PlayerInfoReq = $root.msg.info.playerInfoReq.decode(reader, reader.uint32());
                break;
            case 12:
                message.AdRecordReq = $root.msg.notice.adRecordReq.decode(reader, reader.uint32());
                break;
            case 13:
                message.AdShowReq = $root.msg.notice.adShowReq.decode(reader, reader.uint32());
                break;
            case 14:
                message.PlayerSetReq = $root.msg.action.playerSetReq.decode(reader, reader.uint32());
                break;
            case 15:
                message.ClientLogReq = $root.msg.action.clientLogReq.decode(reader, reader.uint32());
                break;
            case 16:
                message.PassReq = $root.msg.action.passReq.decode(reader, reader.uint32());
                break;
            case 17:
                message.RecycleLevelReq = $root.msg.action.recycleLevelReq.decode(reader, reader.uint32());
                break;
            case 18:
                message.ctime = reader.string();
                break;
            case 19:
                message.token = reader.string();
                break;
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a C2GS message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof C2GS
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {C2GS} C2GS
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    C2GS.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a C2GS message.
     * @function verify
     * @memberof C2GS
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    C2GS.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.session != null && message.hasOwnProperty("session"))
            if (!$util.isInteger(message.session))
                return "session: integer expected";
        if (message.protocolId != null && message.hasOwnProperty("protocolId"))
            if (!$util.isString(message.protocolId))
                return "protocolId: string expected";
        if (message.SdkUploadReq != null && message.hasOwnProperty("SdkUploadReq")) {
            var error = $root.msg.login.sdkUploadReq.verify(message.SdkUploadReq);
            if (error)
                return "SdkUploadReq." + error;
        }
        if (message.LoginReq != null && message.hasOwnProperty("LoginReq")) {
            var error = $root.msg.login.loginReq.verify(message.LoginReq);
            if (error)
                return "LoginReq." + error;
        }
        if (message.SyncMoneyReq != null && message.hasOwnProperty("SyncMoneyReq")) {
            var error = $root.msg.action.syncMoneyReq.verify(message.SyncMoneyReq);
            if (error)
                return "SyncMoneyReq." + error;
        }
        if (message.SyncPetMagicReq != null && message.hasOwnProperty("SyncPetMagicReq")) {
            var error = $root.msg.action.syncPetMagicReq.verify(message.SyncPetMagicReq);
            if (error)
                return "SyncPetMagicReq." + error;
        }
        if (message.ActivePetMagicReq != null && message.hasOwnProperty("ActivePetMagicReq")) {
            var error = $root.msg.action.activePetMagicReq.verify(message.ActivePetMagicReq);
            if (error)
                return "ActivePetMagicReq." + error;
        }
        if (message.RewardReq != null && message.hasOwnProperty("RewardReq")) {
            var error = $root.msg.action.rewardReq.verify(message.RewardReq);
            if (error)
                return "RewardReq." + error;
        }
        if (message.GetTaskRewardReq != null && message.hasOwnProperty("GetTaskRewardReq")) {
            var error = $root.msg.action.getTaskRewardReq.verify(message.GetTaskRewardReq);
            if (error)
                return "GetTaskRewardReq." + error;
        }
        if (message.CashReq != null && message.hasOwnProperty("CashReq")) {
            var error = $root.msg.action.cashReq.verify(message.CashReq);
            if (error)
                return "CashReq." + error;
        }
        if (message.PlayerInfoReq != null && message.hasOwnProperty("PlayerInfoReq")) {
            var error = $root.msg.info.playerInfoReq.verify(message.PlayerInfoReq);
            if (error)
                return "PlayerInfoReq." + error;
        }
        if (message.AdRecordReq != null && message.hasOwnProperty("AdRecordReq")) {
            var error = $root.msg.notice.adRecordReq.verify(message.AdRecordReq);
            if (error)
                return "AdRecordReq." + error;
        }
        if (message.AdShowReq != null && message.hasOwnProperty("AdShowReq")) {
            var error = $root.msg.notice.adShowReq.verify(message.AdShowReq);
            if (error)
                return "AdShowReq." + error;
        }
        if (message.PlayerSetReq != null && message.hasOwnProperty("PlayerSetReq")) {
            var error = $root.msg.action.playerSetReq.verify(message.PlayerSetReq);
            if (error)
                return "PlayerSetReq." + error;
        }
        if (message.ClientLogReq != null && message.hasOwnProperty("ClientLogReq")) {
            var error = $root.msg.action.clientLogReq.verify(message.ClientLogReq);
            if (error)
                return "ClientLogReq." + error;
        }
        if (message.PassReq != null && message.hasOwnProperty("PassReq")) {
            var error = $root.msg.action.passReq.verify(message.PassReq);
            if (error)
                return "PassReq." + error;
        }
        if (message.RecycleLevelReq != null && message.hasOwnProperty("RecycleLevelReq")) {
            var error = $root.msg.action.recycleLevelReq.verify(message.RecycleLevelReq);
            if (error)
                return "RecycleLevelReq." + error;
        }
        if (message.ctime != null && message.hasOwnProperty("ctime"))
            if (!$util.isString(message.ctime))
                return "ctime: string expected";
        if (message.token != null && message.hasOwnProperty("token"))
            if (!$util.isString(message.token))
                return "token: string expected";
        return null;
    };

    /**
     * Creates a C2GS message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof C2GS
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {C2GS} C2GS
     */
    C2GS.fromObject = function fromObject(object) {
        if (object instanceof $root.C2GS)
            return object;
        var message = new $root.C2GS();
        if (object.session != null)
            message.session = object.session | 0;
        if (object.protocolId != null)
            message.protocolId = String(object.protocolId);
        if (object.SdkUploadReq != null) {
            if (typeof object.SdkUploadReq !== "object")
                throw TypeError(".C2GS.SdkUploadReq: object expected");
            message.SdkUploadReq = $root.msg.login.sdkUploadReq.fromObject(object.SdkUploadReq);
        }
        if (object.LoginReq != null) {
            if (typeof object.LoginReq !== "object")
                throw TypeError(".C2GS.LoginReq: object expected");
            message.LoginReq = $root.msg.login.loginReq.fromObject(object.LoginReq);
        }
        if (object.SyncMoneyReq != null) {
            if (typeof object.SyncMoneyReq !== "object")
                throw TypeError(".C2GS.SyncMoneyReq: object expected");
            message.SyncMoneyReq = $root.msg.action.syncMoneyReq.fromObject(object.SyncMoneyReq);
        }
        if (object.SyncPetMagicReq != null) {
            if (typeof object.SyncPetMagicReq !== "object")
                throw TypeError(".C2GS.SyncPetMagicReq: object expected");
            message.SyncPetMagicReq = $root.msg.action.syncPetMagicReq.fromObject(object.SyncPetMagicReq);
        }
        if (object.ActivePetMagicReq != null) {
            if (typeof object.ActivePetMagicReq !== "object")
                throw TypeError(".C2GS.ActivePetMagicReq: object expected");
            message.ActivePetMagicReq = $root.msg.action.activePetMagicReq.fromObject(object.ActivePetMagicReq);
        }
        if (object.RewardReq != null) {
            if (typeof object.RewardReq !== "object")
                throw TypeError(".C2GS.RewardReq: object expected");
            message.RewardReq = $root.msg.action.rewardReq.fromObject(object.RewardReq);
        }
        if (object.GetTaskRewardReq != null) {
            if (typeof object.GetTaskRewardReq !== "object")
                throw TypeError(".C2GS.GetTaskRewardReq: object expected");
            message.GetTaskRewardReq = $root.msg.action.getTaskRewardReq.fromObject(object.GetTaskRewardReq);
        }
        if (object.CashReq != null) {
            if (typeof object.CashReq !== "object")
                throw TypeError(".C2GS.CashReq: object expected");
            message.CashReq = $root.msg.action.cashReq.fromObject(object.CashReq);
        }
        if (object.PlayerInfoReq != null) {
            if (typeof object.PlayerInfoReq !== "object")
                throw TypeError(".C2GS.PlayerInfoReq: object expected");
            message.PlayerInfoReq = $root.msg.info.playerInfoReq.fromObject(object.PlayerInfoReq);
        }
        if (object.AdRecordReq != null) {
            if (typeof object.AdRecordReq !== "object")
                throw TypeError(".C2GS.AdRecordReq: object expected");
            message.AdRecordReq = $root.msg.notice.adRecordReq.fromObject(object.AdRecordReq);
        }
        if (object.AdShowReq != null) {
            if (typeof object.AdShowReq !== "object")
                throw TypeError(".C2GS.AdShowReq: object expected");
            message.AdShowReq = $root.msg.notice.adShowReq.fromObject(object.AdShowReq);
        }
        if (object.PlayerSetReq != null) {
            if (typeof object.PlayerSetReq !== "object")
                throw TypeError(".C2GS.PlayerSetReq: object expected");
            message.PlayerSetReq = $root.msg.action.playerSetReq.fromObject(object.PlayerSetReq);
        }
        if (object.ClientLogReq != null) {
            if (typeof object.ClientLogReq !== "object")
                throw TypeError(".C2GS.ClientLogReq: object expected");
            message.ClientLogReq = $root.msg.action.clientLogReq.fromObject(object.ClientLogReq);
        }
        if (object.PassReq != null) {
            if (typeof object.PassReq !== "object")
                throw TypeError(".C2GS.PassReq: object expected");
            message.PassReq = $root.msg.action.passReq.fromObject(object.PassReq);
        }
        if (object.RecycleLevelReq != null) {
            if (typeof object.RecycleLevelReq !== "object")
                throw TypeError(".C2GS.RecycleLevelReq: object expected");
            message.RecycleLevelReq = $root.msg.action.recycleLevelReq.fromObject(object.RecycleLevelReq);
        }
        if (object.ctime != null)
            message.ctime = String(object.ctime);
        if (object.token != null)
            message.token = String(object.token);
        return message;
    };

    /**
     * Creates a plain object from a C2GS message. Also converts values to other types if specified.
     * @function toObject
     * @memberof C2GS
     * @static
     * @param {C2GS} message C2GS
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    C2GS.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        var object = {};
        if (options.defaults) {
            object.session = 0;
            object.protocolId = "";
            object.SdkUploadReq = null;
            object.LoginReq = null;
            object.SyncMoneyReq = null;
            object.SyncPetMagicReq = null;
            object.ActivePetMagicReq = null;
            object.RewardReq = null;
            object.GetTaskRewardReq = null;
            object.CashReq = null;
            object.PlayerInfoReq = null;
            object.AdRecordReq = null;
            object.AdShowReq = null;
            object.PlayerSetReq = null;
            object.ClientLogReq = null;
            object.PassReq = null;
            object.RecycleLevelReq = null;
            object.ctime = "";
            object.token = "";
        }
        if (message.session != null && message.hasOwnProperty("session"))
            object.session = message.session;
        if (message.protocolId != null && message.hasOwnProperty("protocolId"))
            object.protocolId = message.protocolId;
        if (message.SdkUploadReq != null && message.hasOwnProperty("SdkUploadReq"))
            object.SdkUploadReq = $root.msg.login.sdkUploadReq.toObject(message.SdkUploadReq, options);
        if (message.LoginReq != null && message.hasOwnProperty("LoginReq"))
            object.LoginReq = $root.msg.login.loginReq.toObject(message.LoginReq, options);
        if (message.SyncMoneyReq != null && message.hasOwnProperty("SyncMoneyReq"))
            object.SyncMoneyReq = $root.msg.action.syncMoneyReq.toObject(message.SyncMoneyReq, options);
        if (message.SyncPetMagicReq != null && message.hasOwnProperty("SyncPetMagicReq"))
            object.SyncPetMagicReq = $root.msg.action.syncPetMagicReq.toObject(message.SyncPetMagicReq, options);
        if (message.ActivePetMagicReq != null && message.hasOwnProperty("ActivePetMagicReq"))
            object.ActivePetMagicReq = $root.msg.action.activePetMagicReq.toObject(message.ActivePetMagicReq, options);
        if (message.RewardReq != null && message.hasOwnProperty("RewardReq"))
            object.RewardReq = $root.msg.action.rewardReq.toObject(message.RewardReq, options);
        if (message.GetTaskRewardReq != null && message.hasOwnProperty("GetTaskRewardReq"))
            object.GetTaskRewardReq = $root.msg.action.getTaskRewardReq.toObject(message.GetTaskRewardReq, options);
        if (message.CashReq != null && message.hasOwnProperty("CashReq"))
            object.CashReq = $root.msg.action.cashReq.toObject(message.CashReq, options);
        if (message.PlayerInfoReq != null && message.hasOwnProperty("PlayerInfoReq"))
            object.PlayerInfoReq = $root.msg.info.playerInfoReq.toObject(message.PlayerInfoReq, options);
        if (message.AdRecordReq != null && message.hasOwnProperty("AdRecordReq"))
            object.AdRecordReq = $root.msg.notice.adRecordReq.toObject(message.AdRecordReq, options);
        if (message.AdShowReq != null && message.hasOwnProperty("AdShowReq"))
            object.AdShowReq = $root.msg.notice.adShowReq.toObject(message.AdShowReq, options);
        if (message.PlayerSetReq != null && message.hasOwnProperty("PlayerSetReq"))
            object.PlayerSetReq = $root.msg.action.playerSetReq.toObject(message.PlayerSetReq, options);
        if (message.ClientLogReq != null && message.hasOwnProperty("ClientLogReq"))
            object.ClientLogReq = $root.msg.action.clientLogReq.toObject(message.ClientLogReq, options);
        if (message.PassReq != null && message.hasOwnProperty("PassReq"))
            object.PassReq = $root.msg.action.passReq.toObject(message.PassReq, options);
        if (message.RecycleLevelReq != null && message.hasOwnProperty("RecycleLevelReq"))
            object.RecycleLevelReq = $root.msg.action.recycleLevelReq.toObject(message.RecycleLevelReq, options);
        if (message.ctime != null && message.hasOwnProperty("ctime"))
            object.ctime = message.ctime;
        if (message.token != null && message.hasOwnProperty("token"))
            object.token = message.token;
        return object;
    };

    /**
     * Converts this C2GS to JSON.
     * @function toJSON
     * @memberof C2GS
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    C2GS.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    return C2GS;
})();

$root.GS2C = (function() {

    /**
     * Properties of a GS2C.
     * @exports IGS2C
     * @interface IGS2C
     * @property {number|null} [session] GS2C session
     * @property {string|null} [protocolId] GS2C protocolId
     * @property {msg.notice.InoticeRet|null} [NoticeRet] GS2C NoticeRet
     * @property {msg.login.IloginRet|null} [LoginRet] GS2C LoginRet
     * @property {msg.info.IplayerInfoRet|null} [PlayerInfoRet] GS2C PlayerInfoRet
     * @property {msg.action.IpetMagicListRet|null} [PetMagicListRet] GS2C PetMagicListRet
     * @property {msg.action.IactivePetMagicRet|null} [ActivePetMagicRet] GS2C ActivePetMagicRet
     * @property {msg.info.IsignListRet|null} [SignListRet] GS2C SignListRet
     * @property {msg.info.ItaskListRet|null} [TaskListRet] GS2C TaskListRet
     * @property {msg.info.IraffleListRet|null} [RaffleListRet] GS2C RaffleListRet
     * @property {msg.action.IraffleResultRet|null} [RaffleResultRet] GS2C RaffleResultRet
     * @property {msg.info.IdividendRet|null} [DividendRet] GS2C DividendRet
     * @property {msg.info.IcashInfoRet|null} [CashInfoRet] GS2C CashInfoRet
     * @property {msg.info.IpopHongbaoRet|null} [PopHongbaoRet] GS2C PopHongbaoRet
     * @property {msg.notice.IadShowRet|null} [AdShowRet] GS2C AdShowRet
     * @property {msg.action.IrewardRet|null} [RewardRet] GS2C RewardRet
     * @property {msg.action.IsyncMoneyRet|null} [SyncMoneyRet] GS2C SyncMoneyRet
     * @property {msg.action.ImoneyAddRet|null} [MoneyAddRet] GS2C MoneyAddRet
     */

    /**
     * Constructs a new GS2C.
     * @exports GS2C
     * @classdesc Represents a GS2C.
     * @implements IGS2C
     * @constructor
     * @param {IGS2C=} [properties] Properties to set
     */
    function GS2C(properties) {
        if (properties)
            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                if (properties[keys[i]] != null)
                    this[keys[i]] = properties[keys[i]];
    }

    /**
     * GS2C session.
     * @member {number} session
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.session = 0;

    /**
     * GS2C protocolId.
     * @member {string} protocolId
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.protocolId = "";

    /**
     * GS2C NoticeRet.
     * @member {msg.notice.InoticeRet|null|undefined} NoticeRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.NoticeRet = null;

    /**
     * GS2C LoginRet.
     * @member {msg.login.IloginRet|null|undefined} LoginRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.LoginRet = null;

    /**
     * GS2C PlayerInfoRet.
     * @member {msg.info.IplayerInfoRet|null|undefined} PlayerInfoRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.PlayerInfoRet = null;

    /**
     * GS2C PetMagicListRet.
     * @member {msg.action.IpetMagicListRet|null|undefined} PetMagicListRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.PetMagicListRet = null;

    /**
     * GS2C ActivePetMagicRet.
     * @member {msg.action.IactivePetMagicRet|null|undefined} ActivePetMagicRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.ActivePetMagicRet = null;

    /**
     * GS2C SignListRet.
     * @member {msg.info.IsignListRet|null|undefined} SignListRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.SignListRet = null;

    /**
     * GS2C TaskListRet.
     * @member {msg.info.ItaskListRet|null|undefined} TaskListRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.TaskListRet = null;

    /**
     * GS2C RaffleListRet.
     * @member {msg.info.IraffleListRet|null|undefined} RaffleListRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.RaffleListRet = null;

    /**
     * GS2C RaffleResultRet.
     * @member {msg.action.IraffleResultRet|null|undefined} RaffleResultRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.RaffleResultRet = null;

    /**
     * GS2C DividendRet.
     * @member {msg.info.IdividendRet|null|undefined} DividendRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.DividendRet = null;

    /**
     * GS2C CashInfoRet.
     * @member {msg.info.IcashInfoRet|null|undefined} CashInfoRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.CashInfoRet = null;

    /**
     * GS2C PopHongbaoRet.
     * @member {msg.info.IpopHongbaoRet|null|undefined} PopHongbaoRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.PopHongbaoRet = null;

    /**
     * GS2C AdShowRet.
     * @member {msg.notice.IadShowRet|null|undefined} AdShowRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.AdShowRet = null;

    /**
     * GS2C RewardRet.
     * @member {msg.action.IrewardRet|null|undefined} RewardRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.RewardRet = null;

    /**
     * GS2C SyncMoneyRet.
     * @member {msg.action.IsyncMoneyRet|null|undefined} SyncMoneyRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.SyncMoneyRet = null;

    /**
     * GS2C MoneyAddRet.
     * @member {msg.action.ImoneyAddRet|null|undefined} MoneyAddRet
     * @memberof GS2C
     * @instance
     */
    GS2C.prototype.MoneyAddRet = null;

    /**
     * Creates a new GS2C instance using the specified properties.
     * @function create
     * @memberof GS2C
     * @static
     * @param {IGS2C=} [properties] Properties to set
     * @returns {GS2C} GS2C instance
     */
    GS2C.create = function create(properties) {
        return new GS2C(properties);
    };

    /**
     * Encodes the specified GS2C message. Does not implicitly {@link GS2C.verify|verify} messages.
     * @function encode
     * @memberof GS2C
     * @static
     * @param {IGS2C} message GS2C message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    GS2C.encode = function encode(message, writer) {
        if (!writer)
            writer = $Writer.create();
        if (message.session != null && Object.hasOwnProperty.call(message, "session"))
            writer.uint32(/* id 1, wireType 0 =*/8).int32(message.session);
        if (message.protocolId != null && Object.hasOwnProperty.call(message, "protocolId"))
            writer.uint32(/* id 2, wireType 2 =*/18).string(message.protocolId);
        if (message.NoticeRet != null && Object.hasOwnProperty.call(message, "NoticeRet"))
            $root.msg.notice.noticeRet.encode(message.NoticeRet, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
        if (message.LoginRet != null && Object.hasOwnProperty.call(message, "LoginRet"))
            $root.msg.login.loginRet.encode(message.LoginRet, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
        if (message.PlayerInfoRet != null && Object.hasOwnProperty.call(message, "PlayerInfoRet"))
            $root.msg.info.playerInfoRet.encode(message.PlayerInfoRet, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
        if (message.PetMagicListRet != null && Object.hasOwnProperty.call(message, "PetMagicListRet"))
            $root.msg.action.petMagicListRet.encode(message.PetMagicListRet, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
        if (message.ActivePetMagicRet != null && Object.hasOwnProperty.call(message, "ActivePetMagicRet"))
            $root.msg.action.activePetMagicRet.encode(message.ActivePetMagicRet, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
        if (message.SignListRet != null && Object.hasOwnProperty.call(message, "SignListRet"))
            $root.msg.info.signListRet.encode(message.SignListRet, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
        if (message.TaskListRet != null && Object.hasOwnProperty.call(message, "TaskListRet"))
            $root.msg.info.taskListRet.encode(message.TaskListRet, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
        if (message.RaffleListRet != null && Object.hasOwnProperty.call(message, "RaffleListRet"))
            $root.msg.info.raffleListRet.encode(message.RaffleListRet, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
        if (message.RaffleResultRet != null && Object.hasOwnProperty.call(message, "RaffleResultRet"))
            $root.msg.action.raffleResultRet.encode(message.RaffleResultRet, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
        if (message.DividendRet != null && Object.hasOwnProperty.call(message, "DividendRet"))
            $root.msg.info.dividendRet.encode(message.DividendRet, writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
        if (message.CashInfoRet != null && Object.hasOwnProperty.call(message, "CashInfoRet"))
            $root.msg.info.cashInfoRet.encode(message.CashInfoRet, writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
        if (message.PopHongbaoRet != null && Object.hasOwnProperty.call(message, "PopHongbaoRet"))
            $root.msg.info.popHongbaoRet.encode(message.PopHongbaoRet, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
        if (message.AdShowRet != null && Object.hasOwnProperty.call(message, "AdShowRet"))
            $root.msg.notice.adShowRet.encode(message.AdShowRet, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
        if (message.RewardRet != null && Object.hasOwnProperty.call(message, "RewardRet"))
            $root.msg.action.rewardRet.encode(message.RewardRet, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
        if (message.SyncMoneyRet != null && Object.hasOwnProperty.call(message, "SyncMoneyRet"))
            $root.msg.action.syncMoneyRet.encode(message.SyncMoneyRet, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
        if (message.MoneyAddRet != null && Object.hasOwnProperty.call(message, "MoneyAddRet"))
            $root.msg.action.moneyAddRet.encode(message.MoneyAddRet, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
        return writer;
    };

    /**
     * Encodes the specified GS2C message, length delimited. Does not implicitly {@link GS2C.verify|verify} messages.
     * @function encodeDelimited
     * @memberof GS2C
     * @static
     * @param {IGS2C} message GS2C message or plain object to encode
     * @param {$protobuf.Writer} [writer] Writer to encode to
     * @returns {$protobuf.Writer} Writer
     */
    GS2C.encodeDelimited = function encodeDelimited(message, writer) {
        return this.encode(message, writer).ldelim();
    };

    /**
     * Decodes a GS2C message from the specified reader or buffer.
     * @function decode
     * @memberof GS2C
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @param {number} [length] Message length if known beforehand
     * @returns {GS2C} GS2C
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    GS2C.decode = function decode(reader, length) {
        if (!(reader instanceof $Reader))
            reader = $Reader.create(reader);
        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.GS2C();
        while (reader.pos < end) {
            var tag = reader.uint32();
            switch (tag >>> 3) {
            case 1:
                message.session = reader.int32();
                break;
            case 2:
                message.protocolId = reader.string();
                break;
            case 3:
                message.NoticeRet = $root.msg.notice.noticeRet.decode(reader, reader.uint32());
                break;
            case 4:
                message.LoginRet = $root.msg.login.loginRet.decode(reader, reader.uint32());
                break;
            case 5:
                message.PlayerInfoRet = $root.msg.info.playerInfoRet.decode(reader, reader.uint32());
                break;
            case 6:
                message.PetMagicListRet = $root.msg.action.petMagicListRet.decode(reader, reader.uint32());
                break;
            case 7:
                message.ActivePetMagicRet = $root.msg.action.activePetMagicRet.decode(reader, reader.uint32());
                break;
            case 8:
                message.SignListRet = $root.msg.info.signListRet.decode(reader, reader.uint32());
                break;
            case 9:
                message.TaskListRet = $root.msg.info.taskListRet.decode(reader, reader.uint32());
                break;
            case 10:
                message.RaffleListRet = $root.msg.info.raffleListRet.decode(reader, reader.uint32());
                break;
            case 11:
                message.RaffleResultRet = $root.msg.action.raffleResultRet.decode(reader, reader.uint32());
                break;
            case 12:
                message.DividendRet = $root.msg.info.dividendRet.decode(reader, reader.uint32());
                break;
            case 13:
                message.CashInfoRet = $root.msg.info.cashInfoRet.decode(reader, reader.uint32());
                break;
            case 14:
                message.PopHongbaoRet = $root.msg.info.popHongbaoRet.decode(reader, reader.uint32());
                break;
            case 15:
                message.AdShowRet = $root.msg.notice.adShowRet.decode(reader, reader.uint32());
                break;
            case 16:
                message.RewardRet = $root.msg.action.rewardRet.decode(reader, reader.uint32());
                break;
            case 17:
                message.SyncMoneyRet = $root.msg.action.syncMoneyRet.decode(reader, reader.uint32());
                break;
            case 18:
                message.MoneyAddRet = $root.msg.action.moneyAddRet.decode(reader, reader.uint32());
                break;
            default:
                reader.skipType(tag & 7);
                break;
            }
        }
        return message;
    };

    /**
     * Decodes a GS2C message from the specified reader or buffer, length delimited.
     * @function decodeDelimited
     * @memberof GS2C
     * @static
     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
     * @returns {GS2C} GS2C
     * @throws {Error} If the payload is not a reader or valid buffer
     * @throws {$protobuf.util.ProtocolError} If required fields are missing
     */
    GS2C.decodeDelimited = function decodeDelimited(reader) {
        if (!(reader instanceof $Reader))
            reader = new $Reader(reader);
        return this.decode(reader, reader.uint32());
    };

    /**
     * Verifies a GS2C message.
     * @function verify
     * @memberof GS2C
     * @static
     * @param {Object.<string,*>} message Plain object to verify
     * @returns {string|null} `null` if valid, otherwise the reason why it is not
     */
    GS2C.verify = function verify(message) {
        if (typeof message !== "object" || message === null)
            return "object expected";
        if (message.session != null && message.hasOwnProperty("session"))
            if (!$util.isInteger(message.session))
                return "session: integer expected";
        if (message.protocolId != null && message.hasOwnProperty("protocolId"))
            if (!$util.isString(message.protocolId))
                return "protocolId: string expected";
        if (message.NoticeRet != null && message.hasOwnProperty("NoticeRet")) {
            var error = $root.msg.notice.noticeRet.verify(message.NoticeRet);
            if (error)
                return "NoticeRet." + error;
        }
        if (message.LoginRet != null && message.hasOwnProperty("LoginRet")) {
            var error = $root.msg.login.loginRet.verify(message.LoginRet);
            if (error)
                return "LoginRet." + error;
        }
        if (message.PlayerInfoRet != null && message.hasOwnProperty("PlayerInfoRet")) {
            var error = $root.msg.info.playerInfoRet.verify(message.PlayerInfoRet);
            if (error)
                return "PlayerInfoRet." + error;
        }
        if (message.PetMagicListRet != null && message.hasOwnProperty("PetMagicListRet")) {
            var error = $root.msg.action.petMagicListRet.verify(message.PetMagicListRet);
            if (error)
                return "PetMagicListRet." + error;
        }
        if (message.ActivePetMagicRet != null && message.hasOwnProperty("ActivePetMagicRet")) {
            var error = $root.msg.action.activePetMagicRet.verify(message.ActivePetMagicRet);
            if (error)
                return "ActivePetMagicRet." + error;
        }
        if (message.SignListRet != null && message.hasOwnProperty("SignListRet")) {
            var error = $root.msg.info.signListRet.verify(message.SignListRet);
            if (error)
                return "SignListRet." + error;
        }
        if (message.TaskListRet != null && message.hasOwnProperty("TaskListRet")) {
            var error = $root.msg.info.taskListRet.verify(message.TaskListRet);
            if (error)
                return "TaskListRet." + error;
        }
        if (message.RaffleListRet != null && message.hasOwnProperty("RaffleListRet")) {
            var error = $root.msg.info.raffleListRet.verify(message.RaffleListRet);
            if (error)
                return "RaffleListRet." + error;
        }
        if (message.RaffleResultRet != null && message.hasOwnProperty("RaffleResultRet")) {
            var error = $root.msg.action.raffleResultRet.verify(message.RaffleResultRet);
            if (error)
                return "RaffleResultRet." + error;
        }
        if (message.DividendRet != null && message.hasOwnProperty("DividendRet")) {
            var error = $root.msg.info.dividendRet.verify(message.DividendRet);
            if (error)
                return "DividendRet." + error;
        }
        if (message.CashInfoRet != null && message.hasOwnProperty("CashInfoRet")) {
            var error = $root.msg.info.cashInfoRet.verify(message.CashInfoRet);
            if (error)
                return "CashInfoRet." + error;
        }
        if (message.PopHongbaoRet != null && message.hasOwnProperty("PopHongbaoRet")) {
            var error = $root.msg.info.popHongbaoRet.verify(message.PopHongbaoRet);
            if (error)
                return "PopHongbaoRet." + error;
        }
        if (message.AdShowRet != null && message.hasOwnProperty("AdShowRet")) {
            var error = $root.msg.notice.adShowRet.verify(message.AdShowRet);
            if (error)
                return "AdShowRet." + error;
        }
        if (message.RewardRet != null && message.hasOwnProperty("RewardRet")) {
            var error = $root.msg.action.rewardRet.verify(message.RewardRet);
            if (error)
                return "RewardRet." + error;
        }
        if (message.SyncMoneyRet != null && message.hasOwnProperty("SyncMoneyRet")) {
            var error = $root.msg.action.syncMoneyRet.verify(message.SyncMoneyRet);
            if (error)
                return "SyncMoneyRet." + error;
        }
        if (message.MoneyAddRet != null && message.hasOwnProperty("MoneyAddRet")) {
            var error = $root.msg.action.moneyAddRet.verify(message.MoneyAddRet);
            if (error)
                return "MoneyAddRet." + error;
        }
        return null;
    };

    /**
     * Creates a GS2C message from a plain object. Also converts values to their respective internal types.
     * @function fromObject
     * @memberof GS2C
     * @static
     * @param {Object.<string,*>} object Plain object
     * @returns {GS2C} GS2C
     */
    GS2C.fromObject = function fromObject(object) {
        if (object instanceof $root.GS2C)
            return object;
        var message = new $root.GS2C();
        if (object.session != null)
            message.session = object.session | 0;
        if (object.protocolId != null)
            message.protocolId = String(object.protocolId);
        if (object.NoticeRet != null) {
            if (typeof object.NoticeRet !== "object")
                throw TypeError(".GS2C.NoticeRet: object expected");
            message.NoticeRet = $root.msg.notice.noticeRet.fromObject(object.NoticeRet);
        }
        if (object.LoginRet != null) {
            if (typeof object.LoginRet !== "object")
                throw TypeError(".GS2C.LoginRet: object expected");
            message.LoginRet = $root.msg.login.loginRet.fromObject(object.LoginRet);
        }
        if (object.PlayerInfoRet != null) {
            if (typeof object.PlayerInfoRet !== "object")
                throw TypeError(".GS2C.PlayerInfoRet: object expected");
            message.PlayerInfoRet = $root.msg.info.playerInfoRet.fromObject(object.PlayerInfoRet);
        }
        if (object.PetMagicListRet != null) {
            if (typeof object.PetMagicListRet !== "object")
                throw TypeError(".GS2C.PetMagicListRet: object expected");
            message.PetMagicListRet = $root.msg.action.petMagicListRet.fromObject(object.PetMagicListRet);
        }
        if (object.ActivePetMagicRet != null) {
            if (typeof object.ActivePetMagicRet !== "object")
                throw TypeError(".GS2C.ActivePetMagicRet: object expected");
            message.ActivePetMagicRet = $root.msg.action.activePetMagicRet.fromObject(object.ActivePetMagicRet);
        }
        if (object.SignListRet != null) {
            if (typeof object.SignListRet !== "object")
                throw TypeError(".GS2C.SignListRet: object expected");
            message.SignListRet = $root.msg.info.signListRet.fromObject(object.SignListRet);
        }
        if (object.TaskListRet != null) {
            if (typeof object.TaskListRet !== "object")
                throw TypeError(".GS2C.TaskListRet: object expected");
            message.TaskListRet = $root.msg.info.taskListRet.fromObject(object.TaskListRet);
        }
        if (object.RaffleListRet != null) {
            if (typeof object.RaffleListRet !== "object")
                throw TypeError(".GS2C.RaffleListRet: object expected");
            message.RaffleListRet = $root.msg.info.raffleListRet.fromObject(object.RaffleListRet);
        }
        if (object.RaffleResultRet != null) {
            if (typeof object.RaffleResultRet !== "object")
                throw TypeError(".GS2C.RaffleResultRet: object expected");
            message.RaffleResultRet = $root.msg.action.raffleResultRet.fromObject(object.RaffleResultRet);
        }
        if (object.DividendRet != null) {
            if (typeof object.DividendRet !== "object")
                throw TypeError(".GS2C.DividendRet: object expected");
            message.DividendRet = $root.msg.info.dividendRet.fromObject(object.DividendRet);
        }
        if (object.CashInfoRet != null) {
            if (typeof object.CashInfoRet !== "object")
                throw TypeError(".GS2C.CashInfoRet: object expected");
            message.CashInfoRet = $root.msg.info.cashInfoRet.fromObject(object.CashInfoRet);
        }
        if (object.PopHongbaoRet != null) {
            if (typeof object.PopHongbaoRet !== "object")
                throw TypeError(".GS2C.PopHongbaoRet: object expected");
            message.PopHongbaoRet = $root.msg.info.popHongbaoRet.fromObject(object.PopHongbaoRet);
        }
        if (object.AdShowRet != null) {
            if (typeof object.AdShowRet !== "object")
                throw TypeError(".GS2C.AdShowRet: object expected");
            message.AdShowRet = $root.msg.notice.adShowRet.fromObject(object.AdShowRet);
        }
        if (object.RewardRet != null) {
            if (typeof object.RewardRet !== "object")
                throw TypeError(".GS2C.RewardRet: object expected");
            message.RewardRet = $root.msg.action.rewardRet.fromObject(object.RewardRet);
        }
        if (object.SyncMoneyRet != null) {
            if (typeof object.SyncMoneyRet !== "object")
                throw TypeError(".GS2C.SyncMoneyRet: object expected");
            message.SyncMoneyRet = $root.msg.action.syncMoneyRet.fromObject(object.SyncMoneyRet);
        }
        if (object.MoneyAddRet != null) {
            if (typeof object.MoneyAddRet !== "object")
                throw TypeError(".GS2C.MoneyAddRet: object expected");
            message.MoneyAddRet = $root.msg.action.moneyAddRet.fromObject(object.MoneyAddRet);
        }
        return message;
    };

    /**
     * Creates a plain object from a GS2C message. Also converts values to other types if specified.
     * @function toObject
     * @memberof GS2C
     * @static
     * @param {GS2C} message GS2C
     * @param {$protobuf.IConversionOptions} [options] Conversion options
     * @returns {Object.<string,*>} Plain object
     */
    GS2C.toObject = function toObject(message, options) {
        if (!options)
            options = {};
        var object = {};
        if (options.defaults) {
            object.session = 0;
            object.protocolId = "";
            object.NoticeRet = null;
            object.LoginRet = null;
            object.PlayerInfoRet = null;
            object.PetMagicListRet = null;
            object.ActivePetMagicRet = null;
            object.SignListRet = null;
            object.TaskListRet = null;
            object.RaffleListRet = null;
            object.RaffleResultRet = null;
            object.DividendRet = null;
            object.CashInfoRet = null;
            object.PopHongbaoRet = null;
            object.AdShowRet = null;
            object.RewardRet = null;
            object.SyncMoneyRet = null;
            object.MoneyAddRet = null;
        }
        if (message.session != null && message.hasOwnProperty("session"))
            object.session = message.session;
        if (message.protocolId != null && message.hasOwnProperty("protocolId"))
            object.protocolId = message.protocolId;
        if (message.NoticeRet != null && message.hasOwnProperty("NoticeRet"))
            object.NoticeRet = $root.msg.notice.noticeRet.toObject(message.NoticeRet, options);
        if (message.LoginRet != null && message.hasOwnProperty("LoginRet"))
            object.LoginRet = $root.msg.login.loginRet.toObject(message.LoginRet, options);
        if (message.PlayerInfoRet != null && message.hasOwnProperty("PlayerInfoRet"))
            object.PlayerInfoRet = $root.msg.info.playerInfoRet.toObject(message.PlayerInfoRet, options);
        if (message.PetMagicListRet != null && message.hasOwnProperty("PetMagicListRet"))
            object.PetMagicListRet = $root.msg.action.petMagicListRet.toObject(message.PetMagicListRet, options);
        if (message.ActivePetMagicRet != null && message.hasOwnProperty("ActivePetMagicRet"))
            object.ActivePetMagicRet = $root.msg.action.activePetMagicRet.toObject(message.ActivePetMagicRet, options);
        if (message.SignListRet != null && message.hasOwnProperty("SignListRet"))
            object.SignListRet = $root.msg.info.signListRet.toObject(message.SignListRet, options);
        if (message.TaskListRet != null && message.hasOwnProperty("TaskListRet"))
            object.TaskListRet = $root.msg.info.taskListRet.toObject(message.TaskListRet, options);
        if (message.RaffleListRet != null && message.hasOwnProperty("RaffleListRet"))
            object.RaffleListRet = $root.msg.info.raffleListRet.toObject(message.RaffleListRet, options);
        if (message.RaffleResultRet != null && message.hasOwnProperty("RaffleResultRet"))
            object.RaffleResultRet = $root.msg.action.raffleResultRet.toObject(message.RaffleResultRet, options);
        if (message.DividendRet != null && message.hasOwnProperty("DividendRet"))
            object.DividendRet = $root.msg.info.dividendRet.toObject(message.DividendRet, options);
        if (message.CashInfoRet != null && message.hasOwnProperty("CashInfoRet"))
            object.CashInfoRet = $root.msg.info.cashInfoRet.toObject(message.CashInfoRet, options);
        if (message.PopHongbaoRet != null && message.hasOwnProperty("PopHongbaoRet"))
            object.PopHongbaoRet = $root.msg.info.popHongbaoRet.toObject(message.PopHongbaoRet, options);
        if (message.AdShowRet != null && message.hasOwnProperty("AdShowRet"))
            object.AdShowRet = $root.msg.notice.adShowRet.toObject(message.AdShowRet, options);
        if (message.RewardRet != null && message.hasOwnProperty("RewardRet"))
            object.RewardRet = $root.msg.action.rewardRet.toObject(message.RewardRet, options);
        if (message.SyncMoneyRet != null && message.hasOwnProperty("SyncMoneyRet"))
            object.SyncMoneyRet = $root.msg.action.syncMoneyRet.toObject(message.SyncMoneyRet, options);
        if (message.MoneyAddRet != null && message.hasOwnProperty("MoneyAddRet"))
            object.MoneyAddRet = $root.msg.action.moneyAddRet.toObject(message.MoneyAddRet, options);
        return object;
    };

    /**
     * Converts this GS2C to JSON.
     * @function toJSON
     * @memberof GS2C
     * @instance
     * @returns {Object.<string,*>} JSON object
     */
    GS2C.prototype.toJSON = function toJSON() {
        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
    };

    return GS2C;
})();

$root.msg = (function() {

    /**
     * Namespace msg.
     * @exports msg
     * @namespace
     */
    var msg = {};

    msg.login = (function() {

        /**
         * Namespace login.
         * @memberof msg
         * @namespace
         */
        var login = {};

        login.loginReq = (function() {

            /**
             * Properties of a loginReq.
             * @memberof msg.login
             * @interface IloginReq
             * @property {string|null} [deviceId] loginReq deviceId
             * @property {string|null} [system] loginReq system
             * @property {number|null} [loginType] loginReq loginType
             * @property {string|null} [appdata] loginReq appdata
             * @property {string|null} [code] loginReq code
             * @property {string|null} [refreteToken] loginReq refreteToken
             * @property {string|null} [avatarUrl] loginReq avatarUrl
             * @property {string|null} [nickName] loginReq nickName
             * @property {string|null} [sdkId] loginReq sdkId
             */

            /**
             * Constructs a new loginReq.
             * @memberof msg.login
             * @classdesc Represents a loginReq.
             * @implements IloginReq
             * @constructor
             * @param {msg.login.IloginReq=} [properties] Properties to set
             */
            function loginReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * loginReq deviceId.
             * @member {string} deviceId
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.deviceId = "";

            /**
             * loginReq system.
             * @member {string} system
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.system = "";

            /**
             * loginReq loginType.
             * @member {number} loginType
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.loginType = 0;

            /**
             * loginReq appdata.
             * @member {string} appdata
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.appdata = "";

            /**
             * loginReq code.
             * @member {string} code
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.code = "";

            /**
             * loginReq refreteToken.
             * @member {string} refreteToken
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.refreteToken = "";

            /**
             * loginReq avatarUrl.
             * @member {string} avatarUrl
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.avatarUrl = "";

            /**
             * loginReq nickName.
             * @member {string} nickName
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.nickName = "";

            /**
             * loginReq sdkId.
             * @member {string} sdkId
             * @memberof msg.login.loginReq
             * @instance
             */
            loginReq.prototype.sdkId = "";

            /**
             * Creates a new loginReq instance using the specified properties.
             * @function create
             * @memberof msg.login.loginReq
             * @static
             * @param {msg.login.IloginReq=} [properties] Properties to set
             * @returns {msg.login.loginReq} loginReq instance
             */
            loginReq.create = function create(properties) {
                return new loginReq(properties);
            };

            /**
             * Encodes the specified loginReq message. Does not implicitly {@link msg.login.loginReq.verify|verify} messages.
             * @function encode
             * @memberof msg.login.loginReq
             * @static
             * @param {msg.login.IloginReq} message loginReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            loginReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.deviceId != null && Object.hasOwnProperty.call(message, "deviceId"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.deviceId);
                if (message.system != null && Object.hasOwnProperty.call(message, "system"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.system);
                if (message.loginType != null && Object.hasOwnProperty.call(message, "loginType"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.loginType);
                if (message.appdata != null && Object.hasOwnProperty.call(message, "appdata"))
                    writer.uint32(/* id 4, wireType 2 =*/34).string(message.appdata);
                if (message.code != null && Object.hasOwnProperty.call(message, "code"))
                    writer.uint32(/* id 5, wireType 2 =*/42).string(message.code);
                if (message.refreteToken != null && Object.hasOwnProperty.call(message, "refreteToken"))
                    writer.uint32(/* id 6, wireType 2 =*/50).string(message.refreteToken);
                if (message.avatarUrl != null && Object.hasOwnProperty.call(message, "avatarUrl"))
                    writer.uint32(/* id 7, wireType 2 =*/58).string(message.avatarUrl);
                if (message.nickName != null && Object.hasOwnProperty.call(message, "nickName"))
                    writer.uint32(/* id 8, wireType 2 =*/66).string(message.nickName);
                if (message.sdkId != null && Object.hasOwnProperty.call(message, "sdkId"))
                    writer.uint32(/* id 9, wireType 2 =*/74).string(message.sdkId);
                return writer;
            };

            /**
             * Encodes the specified loginReq message, length delimited. Does not implicitly {@link msg.login.loginReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.login.loginReq
             * @static
             * @param {msg.login.IloginReq} message loginReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            loginReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a loginReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.login.loginReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.login.loginReq} loginReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            loginReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.login.loginReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.deviceId = reader.string();
                        break;
                    case 2:
                        message.system = reader.string();
                        break;
                    case 3:
                        message.loginType = reader.int32();
                        break;
                    case 4:
                        message.appdata = reader.string();
                        break;
                    case 5:
                        message.code = reader.string();
                        break;
                    case 6:
                        message.refreteToken = reader.string();
                        break;
                    case 7:
                        message.avatarUrl = reader.string();
                        break;
                    case 8:
                        message.nickName = reader.string();
                        break;
                    case 9:
                        message.sdkId = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a loginReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.login.loginReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.login.loginReq} loginReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            loginReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a loginReq message.
             * @function verify
             * @memberof msg.login.loginReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            loginReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.deviceId != null && message.hasOwnProperty("deviceId"))
                    if (!$util.isString(message.deviceId))
                        return "deviceId: string expected";
                if (message.system != null && message.hasOwnProperty("system"))
                    if (!$util.isString(message.system))
                        return "system: string expected";
                if (message.loginType != null && message.hasOwnProperty("loginType"))
                    if (!$util.isInteger(message.loginType))
                        return "loginType: integer expected";
                if (message.appdata != null && message.hasOwnProperty("appdata"))
                    if (!$util.isString(message.appdata))
                        return "appdata: string expected";
                if (message.code != null && message.hasOwnProperty("code"))
                    if (!$util.isString(message.code))
                        return "code: string expected";
                if (message.refreteToken != null && message.hasOwnProperty("refreteToken"))
                    if (!$util.isString(message.refreteToken))
                        return "refreteToken: string expected";
                if (message.avatarUrl != null && message.hasOwnProperty("avatarUrl"))
                    if (!$util.isString(message.avatarUrl))
                        return "avatarUrl: string expected";
                if (message.nickName != null && message.hasOwnProperty("nickName"))
                    if (!$util.isString(message.nickName))
                        return "nickName: string expected";
                if (message.sdkId != null && message.hasOwnProperty("sdkId"))
                    if (!$util.isString(message.sdkId))
                        return "sdkId: string expected";
                return null;
            };

            /**
             * Creates a loginReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.login.loginReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.login.loginReq} loginReq
             */
            loginReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.login.loginReq)
                    return object;
                var message = new $root.msg.login.loginReq();
                if (object.deviceId != null)
                    message.deviceId = String(object.deviceId);
                if (object.system != null)
                    message.system = String(object.system);
                if (object.loginType != null)
                    message.loginType = object.loginType | 0;
                if (object.appdata != null)
                    message.appdata = String(object.appdata);
                if (object.code != null)
                    message.code = String(object.code);
                if (object.refreteToken != null)
                    message.refreteToken = String(object.refreteToken);
                if (object.avatarUrl != null)
                    message.avatarUrl = String(object.avatarUrl);
                if (object.nickName != null)
                    message.nickName = String(object.nickName);
                if (object.sdkId != null)
                    message.sdkId = String(object.sdkId);
                return message;
            };

            /**
             * Creates a plain object from a loginReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.login.loginReq
             * @static
             * @param {msg.login.loginReq} message loginReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            loginReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.deviceId = "";
                    object.system = "";
                    object.loginType = 0;
                    object.appdata = "";
                    object.code = "";
                    object.refreteToken = "";
                    object.avatarUrl = "";
                    object.nickName = "";
                    object.sdkId = "";
                }
                if (message.deviceId != null && message.hasOwnProperty("deviceId"))
                    object.deviceId = message.deviceId;
                if (message.system != null && message.hasOwnProperty("system"))
                    object.system = message.system;
                if (message.loginType != null && message.hasOwnProperty("loginType"))
                    object.loginType = message.loginType;
                if (message.appdata != null && message.hasOwnProperty("appdata"))
                    object.appdata = message.appdata;
                if (message.code != null && message.hasOwnProperty("code"))
                    object.code = message.code;
                if (message.refreteToken != null && message.hasOwnProperty("refreteToken"))
                    object.refreteToken = message.refreteToken;
                if (message.avatarUrl != null && message.hasOwnProperty("avatarUrl"))
                    object.avatarUrl = message.avatarUrl;
                if (message.nickName != null && message.hasOwnProperty("nickName"))
                    object.nickName = message.nickName;
                if (message.sdkId != null && message.hasOwnProperty("sdkId"))
                    object.sdkId = message.sdkId;
                return object;
            };

            /**
             * Converts this loginReq to JSON.
             * @function toJSON
             * @memberof msg.login.loginReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            loginReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return loginReq;
        })();

        login.loginRet = (function() {

            /**
             * Properties of a loginRet.
             * @memberof msg.login
             * @interface IloginRet
             * @property {string|null} [errormsg] loginRet errormsg
             * @property {string|null} [openid] loginRet openid
             * @property {string|null} [nickname] loginRet nickname
             * @property {string|null} [headimgurl] loginRet headimgurl
             * @property {string|null} [refreshToken] loginRet refreshToken
             * @property {number|null} [initVerify] loginRet initVerify
             * @property {number|null} [isFormal] loginRet isFormal
             * @property {number|null} [isFirstLogin] loginRet isFirstLogin
             * @property {number|null} [loginType] loginRet loginType
             * @property {number|null} [allowBarrage] loginRet allowBarrage
             * @property {number|null} [isWhitelists] loginRet isWhitelists
             * @property {number|null} [isAu] loginRet isAu
             * @property {number|null} [isSdkUpload] loginRet isSdkUpload
             * @property {number|null} [marbleNum] loginRet marbleNum
             * @property {number|null} [offlineTime] loginRet offlineTime
             * @property {string|null} [offlineReward] loginRet offlineReward
             */

            /**
             * Constructs a new loginRet.
             * @memberof msg.login
             * @classdesc Represents a loginRet.
             * @implements IloginRet
             * @constructor
             * @param {msg.login.IloginRet=} [properties] Properties to set
             */
            function loginRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * loginRet errormsg.
             * @member {string} errormsg
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.errormsg = "";

            /**
             * loginRet openid.
             * @member {string} openid
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.openid = "";

            /**
             * loginRet nickname.
             * @member {string} nickname
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.nickname = "";

            /**
             * loginRet headimgurl.
             * @member {string} headimgurl
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.headimgurl = "";

            /**
             * loginRet refreshToken.
             * @member {string} refreshToken
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.refreshToken = "";

            /**
             * loginRet initVerify.
             * @member {number} initVerify
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.initVerify = 0;

            /**
             * loginRet isFormal.
             * @member {number} isFormal
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.isFormal = 0;

            /**
             * loginRet isFirstLogin.
             * @member {number} isFirstLogin
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.isFirstLogin = 0;

            /**
             * loginRet loginType.
             * @member {number} loginType
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.loginType = 0;

            /**
             * loginRet allowBarrage.
             * @member {number} allowBarrage
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.allowBarrage = 0;

            /**
             * loginRet isWhitelists.
             * @member {number} isWhitelists
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.isWhitelists = 0;

            /**
             * loginRet isAu.
             * @member {number} isAu
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.isAu = 0;

            /**
             * loginRet isSdkUpload.
             * @member {number} isSdkUpload
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.isSdkUpload = 0;

            /**
             * loginRet marbleNum.
             * @member {number} marbleNum
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.marbleNum = 0;

            /**
             * loginRet offlineTime.
             * @member {number} offlineTime
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.offlineTime = 0;

            /**
             * loginRet offlineReward.
             * @member {string} offlineReward
             * @memberof msg.login.loginRet
             * @instance
             */
            loginRet.prototype.offlineReward = "";

            /**
             * Creates a new loginRet instance using the specified properties.
             * @function create
             * @memberof msg.login.loginRet
             * @static
             * @param {msg.login.IloginRet=} [properties] Properties to set
             * @returns {msg.login.loginRet} loginRet instance
             */
            loginRet.create = function create(properties) {
                return new loginRet(properties);
            };

            /**
             * Encodes the specified loginRet message. Does not implicitly {@link msg.login.loginRet.verify|verify} messages.
             * @function encode
             * @memberof msg.login.loginRet
             * @static
             * @param {msg.login.IloginRet} message loginRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            loginRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.errormsg != null && Object.hasOwnProperty.call(message, "errormsg"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.errormsg);
                if (message.openid != null && Object.hasOwnProperty.call(message, "openid"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.openid);
                if (message.nickname != null && Object.hasOwnProperty.call(message, "nickname"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.nickname);
                if (message.headimgurl != null && Object.hasOwnProperty.call(message, "headimgurl"))
                    writer.uint32(/* id 4, wireType 2 =*/34).string(message.headimgurl);
                if (message.refreshToken != null && Object.hasOwnProperty.call(message, "refreshToken"))
                    writer.uint32(/* id 5, wireType 2 =*/42).string(message.refreshToken);
                if (message.initVerify != null && Object.hasOwnProperty.call(message, "initVerify"))
                    writer.uint32(/* id 6, wireType 0 =*/48).int32(message.initVerify);
                if (message.isFormal != null && Object.hasOwnProperty.call(message, "isFormal"))
                    writer.uint32(/* id 7, wireType 0 =*/56).int32(message.isFormal);
                if (message.isFirstLogin != null && Object.hasOwnProperty.call(message, "isFirstLogin"))
                    writer.uint32(/* id 8, wireType 0 =*/64).int32(message.isFirstLogin);
                if (message.loginType != null && Object.hasOwnProperty.call(message, "loginType"))
                    writer.uint32(/* id 9, wireType 0 =*/72).int32(message.loginType);
                if (message.allowBarrage != null && Object.hasOwnProperty.call(message, "allowBarrage"))
                    writer.uint32(/* id 10, wireType 0 =*/80).int32(message.allowBarrage);
                if (message.isWhitelists != null && Object.hasOwnProperty.call(message, "isWhitelists"))
                    writer.uint32(/* id 11, wireType 0 =*/88).int32(message.isWhitelists);
                if (message.isAu != null && Object.hasOwnProperty.call(message, "isAu"))
                    writer.uint32(/* id 12, wireType 0 =*/96).int32(message.isAu);
                if (message.isSdkUpload != null && Object.hasOwnProperty.call(message, "isSdkUpload"))
                    writer.uint32(/* id 13, wireType 0 =*/104).int32(message.isSdkUpload);
                if (message.marbleNum != null && Object.hasOwnProperty.call(message, "marbleNum"))
                    writer.uint32(/* id 14, wireType 0 =*/112).int32(message.marbleNum);
                if (message.offlineTime != null && Object.hasOwnProperty.call(message, "offlineTime"))
                    writer.uint32(/* id 15, wireType 0 =*/120).int32(message.offlineTime);
                if (message.offlineReward != null && Object.hasOwnProperty.call(message, "offlineReward"))
                    writer.uint32(/* id 16, wireType 2 =*/130).string(message.offlineReward);
                return writer;
            };

            /**
             * Encodes the specified loginRet message, length delimited. Does not implicitly {@link msg.login.loginRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.login.loginRet
             * @static
             * @param {msg.login.IloginRet} message loginRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            loginRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a loginRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.login.loginRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.login.loginRet} loginRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            loginRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.login.loginRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.errormsg = reader.string();
                        break;
                    case 2:
                        message.openid = reader.string();
                        break;
                    case 3:
                        message.nickname = reader.string();
                        break;
                    case 4:
                        message.headimgurl = reader.string();
                        break;
                    case 5:
                        message.refreshToken = reader.string();
                        break;
                    case 6:
                        message.initVerify = reader.int32();
                        break;
                    case 7:
                        message.isFormal = reader.int32();
                        break;
                    case 8:
                        message.isFirstLogin = reader.int32();
                        break;
                    case 9:
                        message.loginType = reader.int32();
                        break;
                    case 10:
                        message.allowBarrage = reader.int32();
                        break;
                    case 11:
                        message.isWhitelists = reader.int32();
                        break;
                    case 12:
                        message.isAu = reader.int32();
                        break;
                    case 13:
                        message.isSdkUpload = reader.int32();
                        break;
                    case 14:
                        message.marbleNum = reader.int32();
                        break;
                    case 15:
                        message.offlineTime = reader.int32();
                        break;
                    case 16:
                        message.offlineReward = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a loginRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.login.loginRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.login.loginRet} loginRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            loginRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a loginRet message.
             * @function verify
             * @memberof msg.login.loginRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            loginRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.errormsg != null && message.hasOwnProperty("errormsg"))
                    if (!$util.isString(message.errormsg))
                        return "errormsg: string expected";
                if (message.openid != null && message.hasOwnProperty("openid"))
                    if (!$util.isString(message.openid))
                        return "openid: string expected";
                if (message.nickname != null && message.hasOwnProperty("nickname"))
                    if (!$util.isString(message.nickname))
                        return "nickname: string expected";
                if (message.headimgurl != null && message.hasOwnProperty("headimgurl"))
                    if (!$util.isString(message.headimgurl))
                        return "headimgurl: string expected";
                if (message.refreshToken != null && message.hasOwnProperty("refreshToken"))
                    if (!$util.isString(message.refreshToken))
                        return "refreshToken: string expected";
                if (message.initVerify != null && message.hasOwnProperty("initVerify"))
                    if (!$util.isInteger(message.initVerify))
                        return "initVerify: integer expected";
                if (message.isFormal != null && message.hasOwnProperty("isFormal"))
                    if (!$util.isInteger(message.isFormal))
                        return "isFormal: integer expected";
                if (message.isFirstLogin != null && message.hasOwnProperty("isFirstLogin"))
                    if (!$util.isInteger(message.isFirstLogin))
                        return "isFirstLogin: integer expected";
                if (message.loginType != null && message.hasOwnProperty("loginType"))
                    if (!$util.isInteger(message.loginType))
                        return "loginType: integer expected";
                if (message.allowBarrage != null && message.hasOwnProperty("allowBarrage"))
                    if (!$util.isInteger(message.allowBarrage))
                        return "allowBarrage: integer expected";
                if (message.isWhitelists != null && message.hasOwnProperty("isWhitelists"))
                    if (!$util.isInteger(message.isWhitelists))
                        return "isWhitelists: integer expected";
                if (message.isAu != null && message.hasOwnProperty("isAu"))
                    if (!$util.isInteger(message.isAu))
                        return "isAu: integer expected";
                if (message.isSdkUpload != null && message.hasOwnProperty("isSdkUpload"))
                    if (!$util.isInteger(message.isSdkUpload))
                        return "isSdkUpload: integer expected";
                if (message.marbleNum != null && message.hasOwnProperty("marbleNum"))
                    if (!$util.isInteger(message.marbleNum))
                        return "marbleNum: integer expected";
                if (message.offlineTime != null && message.hasOwnProperty("offlineTime"))
                    if (!$util.isInteger(message.offlineTime))
                        return "offlineTime: integer expected";
                if (message.offlineReward != null && message.hasOwnProperty("offlineReward"))
                    if (!$util.isString(message.offlineReward))
                        return "offlineReward: string expected";
                return null;
            };

            /**
             * Creates a loginRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.login.loginRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.login.loginRet} loginRet
             */
            loginRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.login.loginRet)
                    return object;
                var message = new $root.msg.login.loginRet();
                if (object.errormsg != null)
                    message.errormsg = String(object.errormsg);
                if (object.openid != null)
                    message.openid = String(object.openid);
                if (object.nickname != null)
                    message.nickname = String(object.nickname);
                if (object.headimgurl != null)
                    message.headimgurl = String(object.headimgurl);
                if (object.refreshToken != null)
                    message.refreshToken = String(object.refreshToken);
                if (object.initVerify != null)
                    message.initVerify = object.initVerify | 0;
                if (object.isFormal != null)
                    message.isFormal = object.isFormal | 0;
                if (object.isFirstLogin != null)
                    message.isFirstLogin = object.isFirstLogin | 0;
                if (object.loginType != null)
                    message.loginType = object.loginType | 0;
                if (object.allowBarrage != null)
                    message.allowBarrage = object.allowBarrage | 0;
                if (object.isWhitelists != null)
                    message.isWhitelists = object.isWhitelists | 0;
                if (object.isAu != null)
                    message.isAu = object.isAu | 0;
                if (object.isSdkUpload != null)
                    message.isSdkUpload = object.isSdkUpload | 0;
                if (object.marbleNum != null)
                    message.marbleNum = object.marbleNum | 0;
                if (object.offlineTime != null)
                    message.offlineTime = object.offlineTime | 0;
                if (object.offlineReward != null)
                    message.offlineReward = String(object.offlineReward);
                return message;
            };

            /**
             * Creates a plain object from a loginRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.login.loginRet
             * @static
             * @param {msg.login.loginRet} message loginRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            loginRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.errormsg = "";
                    object.openid = "";
                    object.nickname = "";
                    object.headimgurl = "";
                    object.refreshToken = "";
                    object.initVerify = 0;
                    object.isFormal = 0;
                    object.isFirstLogin = 0;
                    object.loginType = 0;
                    object.allowBarrage = 0;
                    object.isWhitelists = 0;
                    object.isAu = 0;
                    object.isSdkUpload = 0;
                    object.marbleNum = 0;
                    object.offlineTime = 0;
                    object.offlineReward = "";
                }
                if (message.errormsg != null && message.hasOwnProperty("errormsg"))
                    object.errormsg = message.errormsg;
                if (message.openid != null && message.hasOwnProperty("openid"))
                    object.openid = message.openid;
                if (message.nickname != null && message.hasOwnProperty("nickname"))
                    object.nickname = message.nickname;
                if (message.headimgurl != null && message.hasOwnProperty("headimgurl"))
                    object.headimgurl = message.headimgurl;
                if (message.refreshToken != null && message.hasOwnProperty("refreshToken"))
                    object.refreshToken = message.refreshToken;
                if (message.initVerify != null && message.hasOwnProperty("initVerify"))
                    object.initVerify = message.initVerify;
                if (message.isFormal != null && message.hasOwnProperty("isFormal"))
                    object.isFormal = message.isFormal;
                if (message.isFirstLogin != null && message.hasOwnProperty("isFirstLogin"))
                    object.isFirstLogin = message.isFirstLogin;
                if (message.loginType != null && message.hasOwnProperty("loginType"))
                    object.loginType = message.loginType;
                if (message.allowBarrage != null && message.hasOwnProperty("allowBarrage"))
                    object.allowBarrage = message.allowBarrage;
                if (message.isWhitelists != null && message.hasOwnProperty("isWhitelists"))
                    object.isWhitelists = message.isWhitelists;
                if (message.isAu != null && message.hasOwnProperty("isAu"))
                    object.isAu = message.isAu;
                if (message.isSdkUpload != null && message.hasOwnProperty("isSdkUpload"))
                    object.isSdkUpload = message.isSdkUpload;
                if (message.marbleNum != null && message.hasOwnProperty("marbleNum"))
                    object.marbleNum = message.marbleNum;
                if (message.offlineTime != null && message.hasOwnProperty("offlineTime"))
                    object.offlineTime = message.offlineTime;
                if (message.offlineReward != null && message.hasOwnProperty("offlineReward"))
                    object.offlineReward = message.offlineReward;
                return object;
            };

            /**
             * Converts this loginRet to JSON.
             * @function toJSON
             * @memberof msg.login.loginRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            loginRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return loginRet;
        })();

        login.sdkUploadReq = (function() {

            /**
             * Properties of a sdkUploadReq.
             * @memberof msg.login
             * @interface IsdkUploadReq
             * @property {number|null} [state] sdkUploadReq state
             */

            /**
             * Constructs a new sdkUploadReq.
             * @memberof msg.login
             * @classdesc Represents a sdkUploadReq.
             * @implements IsdkUploadReq
             * @constructor
             * @param {msg.login.IsdkUploadReq=} [properties] Properties to set
             */
            function sdkUploadReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * sdkUploadReq state.
             * @member {number} state
             * @memberof msg.login.sdkUploadReq
             * @instance
             */
            sdkUploadReq.prototype.state = 0;

            /**
             * Creates a new sdkUploadReq instance using the specified properties.
             * @function create
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {msg.login.IsdkUploadReq=} [properties] Properties to set
             * @returns {msg.login.sdkUploadReq} sdkUploadReq instance
             */
            sdkUploadReq.create = function create(properties) {
                return new sdkUploadReq(properties);
            };

            /**
             * Encodes the specified sdkUploadReq message. Does not implicitly {@link msg.login.sdkUploadReq.verify|verify} messages.
             * @function encode
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {msg.login.IsdkUploadReq} message sdkUploadReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            sdkUploadReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.state != null && Object.hasOwnProperty.call(message, "state"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.state);
                return writer;
            };

            /**
             * Encodes the specified sdkUploadReq message, length delimited. Does not implicitly {@link msg.login.sdkUploadReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {msg.login.IsdkUploadReq} message sdkUploadReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            sdkUploadReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a sdkUploadReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.login.sdkUploadReq} sdkUploadReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            sdkUploadReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.login.sdkUploadReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.state = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a sdkUploadReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.login.sdkUploadReq} sdkUploadReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            sdkUploadReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a sdkUploadReq message.
             * @function verify
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            sdkUploadReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.state != null && message.hasOwnProperty("state"))
                    if (!$util.isInteger(message.state))
                        return "state: integer expected";
                return null;
            };

            /**
             * Creates a sdkUploadReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.login.sdkUploadReq} sdkUploadReq
             */
            sdkUploadReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.login.sdkUploadReq)
                    return object;
                var message = new $root.msg.login.sdkUploadReq();
                if (object.state != null)
                    message.state = object.state | 0;
                return message;
            };

            /**
             * Creates a plain object from a sdkUploadReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.login.sdkUploadReq
             * @static
             * @param {msg.login.sdkUploadReq} message sdkUploadReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            sdkUploadReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults)
                    object.state = 0;
                if (message.state != null && message.hasOwnProperty("state"))
                    object.state = message.state;
                return object;
            };

            /**
             * Converts this sdkUploadReq to JSON.
             * @function toJSON
             * @memberof msg.login.sdkUploadReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            sdkUploadReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return sdkUploadReq;
        })();

        return login;
    })();

    msg.info = (function() {

        /**
         * Namespace info.
         * @memberof msg
         * @namespace
         */
        var info = {};

        info.playerInfoReq = (function() {

            /**
             * Properties of a playerInfoReq.
             * @memberof msg.info
             * @interface IplayerInfoReq
             * @property {number|null} [type] playerInfoReq type
             */

            /**
             * Constructs a new playerInfoReq.
             * @memberof msg.info
             * @classdesc Represents a playerInfoReq.
             * @implements IplayerInfoReq
             * @constructor
             * @param {msg.info.IplayerInfoReq=} [properties] Properties to set
             */
            function playerInfoReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * playerInfoReq type.
             * @member {number} type
             * @memberof msg.info.playerInfoReq
             * @instance
             */
            playerInfoReq.prototype.type = 0;

            /**
             * Creates a new playerInfoReq instance using the specified properties.
             * @function create
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {msg.info.IplayerInfoReq=} [properties] Properties to set
             * @returns {msg.info.playerInfoReq} playerInfoReq instance
             */
            playerInfoReq.create = function create(properties) {
                return new playerInfoReq(properties);
            };

            /**
             * Encodes the specified playerInfoReq message. Does not implicitly {@link msg.info.playerInfoReq.verify|verify} messages.
             * @function encode
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {msg.info.IplayerInfoReq} message playerInfoReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerInfoReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                return writer;
            };

            /**
             * Encodes the specified playerInfoReq message, length delimited. Does not implicitly {@link msg.info.playerInfoReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {msg.info.IplayerInfoReq} message playerInfoReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerInfoReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a playerInfoReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.playerInfoReq} playerInfoReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerInfoReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.playerInfoReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a playerInfoReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.playerInfoReq} playerInfoReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerInfoReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a playerInfoReq message.
             * @function verify
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            playerInfoReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                return null;
            };

            /**
             * Creates a playerInfoReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.playerInfoReq} playerInfoReq
             */
            playerInfoReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.playerInfoReq)
                    return object;
                var message = new $root.msg.info.playerInfoReq();
                if (object.type != null)
                    message.type = object.type | 0;
                return message;
            };

            /**
             * Creates a plain object from a playerInfoReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.playerInfoReq
             * @static
             * @param {msg.info.playerInfoReq} message playerInfoReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            playerInfoReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults)
                    object.type = 0;
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                return object;
            };

            /**
             * Converts this playerInfoReq to JSON.
             * @function toJSON
             * @memberof msg.info.playerInfoReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            playerInfoReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return playerInfoReq;
        })();

        info.playerInfoRet = (function() {

            /**
             * Properties of a playerInfoRet.
             * @memberof msg.info
             * @interface IplayerInfoRet
             * @property {number|null} [passNum] playerInfoRet passNum
             * @property {string|null} [money] playerInfoRet money
             * @property {number|null} [hongbao] playerInfoRet hongbao
             * @property {number|null} [turntableTimes] playerInfoRet turntableTimes
             * @property {number|null} [nextOnlineHongbaoTime] playerInfoRet nextOnlineHongbaoTime
             * @property {number|null} [onlineHongbaoValue] playerInfoRet onlineHongbaoValue
             * @property {number|null} [bossHongbaoNum] playerInfoRet bossHongbaoNum
             * @property {number|null} [todayAdMoney] playerInfoRet todayAdMoney
             * @property {number|null} [zwHongbaoNum] playerInfoRet zwHongbaoNum
             * @property {number|null} [sgHongbaoNum] playerInfoRet sgHongbaoNum
             * @property {number|null} [sgMonNum] playerInfoRet sgMonNum
             * @property {number|null} [shipinGoldNum] playerInfoRet shipinGoldNum
             * @property {number|null} [physicalCapacity] playerInfoRet physicalCapacity
             * @property {number|null} [todayJumpNum] playerInfoRet todayJumpNum
             * @property {number|null} [todayZhNum] playerInfoRet todayZhNum
             */

            /**
             * Constructs a new playerInfoRet.
             * @memberof msg.info
             * @classdesc Represents a playerInfoRet.
             * @implements IplayerInfoRet
             * @constructor
             * @param {msg.info.IplayerInfoRet=} [properties] Properties to set
             */
            function playerInfoRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * playerInfoRet passNum.
             * @member {number} passNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.passNum = 0;

            /**
             * playerInfoRet money.
             * @member {string} money
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.money = "";

            /**
             * playerInfoRet hongbao.
             * @member {number} hongbao
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.hongbao = 0;

            /**
             * playerInfoRet turntableTimes.
             * @member {number} turntableTimes
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.turntableTimes = 0;

            /**
             * playerInfoRet nextOnlineHongbaoTime.
             * @member {number} nextOnlineHongbaoTime
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.nextOnlineHongbaoTime = 0;

            /**
             * playerInfoRet onlineHongbaoValue.
             * @member {number} onlineHongbaoValue
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.onlineHongbaoValue = 0;

            /**
             * playerInfoRet bossHongbaoNum.
             * @member {number} bossHongbaoNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.bossHongbaoNum = 0;

            /**
             * playerInfoRet todayAdMoney.
             * @member {number} todayAdMoney
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.todayAdMoney = 0;

            /**
             * playerInfoRet zwHongbaoNum.
             * @member {number} zwHongbaoNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.zwHongbaoNum = 0;

            /**
             * playerInfoRet sgHongbaoNum.
             * @member {number} sgHongbaoNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.sgHongbaoNum = 0;

            /**
             * playerInfoRet sgMonNum.
             * @member {number} sgMonNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.sgMonNum = 0;

            /**
             * playerInfoRet shipinGoldNum.
             * @member {number} shipinGoldNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.shipinGoldNum = 0;

            /**
             * playerInfoRet physicalCapacity.
             * @member {number} physicalCapacity
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.physicalCapacity = 0;

            /**
             * playerInfoRet todayJumpNum.
             * @member {number} todayJumpNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.todayJumpNum = 0;

            /**
             * playerInfoRet todayZhNum.
             * @member {number} todayZhNum
             * @memberof msg.info.playerInfoRet
             * @instance
             */
            playerInfoRet.prototype.todayZhNum = 0;

            /**
             * Creates a new playerInfoRet instance using the specified properties.
             * @function create
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {msg.info.IplayerInfoRet=} [properties] Properties to set
             * @returns {msg.info.playerInfoRet} playerInfoRet instance
             */
            playerInfoRet.create = function create(properties) {
                return new playerInfoRet(properties);
            };

            /**
             * Encodes the specified playerInfoRet message. Does not implicitly {@link msg.info.playerInfoRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {msg.info.IplayerInfoRet} message playerInfoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerInfoRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.passNum != null && Object.hasOwnProperty.call(message, "passNum"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.passNum);
                if (message.money != null && Object.hasOwnProperty.call(message, "money"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.money);
                if (message.hongbao != null && Object.hasOwnProperty.call(message, "hongbao"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.hongbao);
                if (message.turntableTimes != null && Object.hasOwnProperty.call(message, "turntableTimes"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.turntableTimes);
                if (message.nextOnlineHongbaoTime != null && Object.hasOwnProperty.call(message, "nextOnlineHongbaoTime"))
                    writer.uint32(/* id 5, wireType 0 =*/40).int32(message.nextOnlineHongbaoTime);
                if (message.onlineHongbaoValue != null && Object.hasOwnProperty.call(message, "onlineHongbaoValue"))
                    writer.uint32(/* id 6, wireType 0 =*/48).int32(message.onlineHongbaoValue);
                if (message.bossHongbaoNum != null && Object.hasOwnProperty.call(message, "bossHongbaoNum"))
                    writer.uint32(/* id 7, wireType 0 =*/56).int32(message.bossHongbaoNum);
                if (message.todayAdMoney != null && Object.hasOwnProperty.call(message, "todayAdMoney"))
                    writer.uint32(/* id 8, wireType 0 =*/64).int32(message.todayAdMoney);
                if (message.zwHongbaoNum != null && Object.hasOwnProperty.call(message, "zwHongbaoNum"))
                    writer.uint32(/* id 9, wireType 0 =*/72).int32(message.zwHongbaoNum);
                if (message.sgHongbaoNum != null && Object.hasOwnProperty.call(message, "sgHongbaoNum"))
                    writer.uint32(/* id 10, wireType 0 =*/80).int32(message.sgHongbaoNum);
                if (message.sgMonNum != null && Object.hasOwnProperty.call(message, "sgMonNum"))
                    writer.uint32(/* id 11, wireType 0 =*/88).int32(message.sgMonNum);
                if (message.shipinGoldNum != null && Object.hasOwnProperty.call(message, "shipinGoldNum"))
                    writer.uint32(/* id 12, wireType 0 =*/96).int32(message.shipinGoldNum);
                if (message.physicalCapacity != null && Object.hasOwnProperty.call(message, "physicalCapacity"))
                    writer.uint32(/* id 13, wireType 0 =*/104).int32(message.physicalCapacity);
                if (message.todayJumpNum != null && Object.hasOwnProperty.call(message, "todayJumpNum"))
                    writer.uint32(/* id 14, wireType 0 =*/112).int32(message.todayJumpNum);
                if (message.todayZhNum != null && Object.hasOwnProperty.call(message, "todayZhNum"))
                    writer.uint32(/* id 15, wireType 0 =*/120).int32(message.todayZhNum);
                return writer;
            };

            /**
             * Encodes the specified playerInfoRet message, length delimited. Does not implicitly {@link msg.info.playerInfoRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {msg.info.IplayerInfoRet} message playerInfoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerInfoRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a playerInfoRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.playerInfoRet} playerInfoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerInfoRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.playerInfoRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.passNum = reader.int32();
                        break;
                    case 2:
                        message.money = reader.string();
                        break;
                    case 3:
                        message.hongbao = reader.int32();
                        break;
                    case 4:
                        message.turntableTimes = reader.int32();
                        break;
                    case 5:
                        message.nextOnlineHongbaoTime = reader.int32();
                        break;
                    case 6:
                        message.onlineHongbaoValue = reader.int32();
                        break;
                    case 7:
                        message.bossHongbaoNum = reader.int32();
                        break;
                    case 8:
                        message.todayAdMoney = reader.int32();
                        break;
                    case 9:
                        message.zwHongbaoNum = reader.int32();
                        break;
                    case 10:
                        message.sgHongbaoNum = reader.int32();
                        break;
                    case 11:
                        message.sgMonNum = reader.int32();
                        break;
                    case 12:
                        message.shipinGoldNum = reader.int32();
                        break;
                    case 13:
                        message.physicalCapacity = reader.int32();
                        break;
                    case 14:
                        message.todayJumpNum = reader.int32();
                        break;
                    case 15:
                        message.todayZhNum = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a playerInfoRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.playerInfoRet} playerInfoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerInfoRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a playerInfoRet message.
             * @function verify
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            playerInfoRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.passNum != null && message.hasOwnProperty("passNum"))
                    if (!$util.isInteger(message.passNum))
                        return "passNum: integer expected";
                if (message.money != null && message.hasOwnProperty("money"))
                    if (!$util.isString(message.money))
                        return "money: string expected";
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    if (!$util.isInteger(message.hongbao))
                        return "hongbao: integer expected";
                if (message.turntableTimes != null && message.hasOwnProperty("turntableTimes"))
                    if (!$util.isInteger(message.turntableTimes))
                        return "turntableTimes: integer expected";
                if (message.nextOnlineHongbaoTime != null && message.hasOwnProperty("nextOnlineHongbaoTime"))
                    if (!$util.isInteger(message.nextOnlineHongbaoTime))
                        return "nextOnlineHongbaoTime: integer expected";
                if (message.onlineHongbaoValue != null && message.hasOwnProperty("onlineHongbaoValue"))
                    if (!$util.isInteger(message.onlineHongbaoValue))
                        return "onlineHongbaoValue: integer expected";
                if (message.bossHongbaoNum != null && message.hasOwnProperty("bossHongbaoNum"))
                    if (!$util.isInteger(message.bossHongbaoNum))
                        return "bossHongbaoNum: integer expected";
                if (message.todayAdMoney != null && message.hasOwnProperty("todayAdMoney"))
                    if (!$util.isInteger(message.todayAdMoney))
                        return "todayAdMoney: integer expected";
                if (message.zwHongbaoNum != null && message.hasOwnProperty("zwHongbaoNum"))
                    if (!$util.isInteger(message.zwHongbaoNum))
                        return "zwHongbaoNum: integer expected";
                if (message.sgHongbaoNum != null && message.hasOwnProperty("sgHongbaoNum"))
                    if (!$util.isInteger(message.sgHongbaoNum))
                        return "sgHongbaoNum: integer expected";
                if (message.sgMonNum != null && message.hasOwnProperty("sgMonNum"))
                    if (!$util.isInteger(message.sgMonNum))
                        return "sgMonNum: integer expected";
                if (message.shipinGoldNum != null && message.hasOwnProperty("shipinGoldNum"))
                    if (!$util.isInteger(message.shipinGoldNum))
                        return "shipinGoldNum: integer expected";
                if (message.physicalCapacity != null && message.hasOwnProperty("physicalCapacity"))
                    if (!$util.isInteger(message.physicalCapacity))
                        return "physicalCapacity: integer expected";
                if (message.todayJumpNum != null && message.hasOwnProperty("todayJumpNum"))
                    if (!$util.isInteger(message.todayJumpNum))
                        return "todayJumpNum: integer expected";
                if (message.todayZhNum != null && message.hasOwnProperty("todayZhNum"))
                    if (!$util.isInteger(message.todayZhNum))
                        return "todayZhNum: integer expected";
                return null;
            };

            /**
             * Creates a playerInfoRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.playerInfoRet} playerInfoRet
             */
            playerInfoRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.playerInfoRet)
                    return object;
                var message = new $root.msg.info.playerInfoRet();
                if (object.passNum != null)
                    message.passNum = object.passNum | 0;
                if (object.money != null)
                    message.money = String(object.money);
                if (object.hongbao != null)
                    message.hongbao = object.hongbao | 0;
                if (object.turntableTimes != null)
                    message.turntableTimes = object.turntableTimes | 0;
                if (object.nextOnlineHongbaoTime != null)
                    message.nextOnlineHongbaoTime = object.nextOnlineHongbaoTime | 0;
                if (object.onlineHongbaoValue != null)
                    message.onlineHongbaoValue = object.onlineHongbaoValue | 0;
                if (object.bossHongbaoNum != null)
                    message.bossHongbaoNum = object.bossHongbaoNum | 0;
                if (object.todayAdMoney != null)
                    message.todayAdMoney = object.todayAdMoney | 0;
                if (object.zwHongbaoNum != null)
                    message.zwHongbaoNum = object.zwHongbaoNum | 0;
                if (object.sgHongbaoNum != null)
                    message.sgHongbaoNum = object.sgHongbaoNum | 0;
                if (object.sgMonNum != null)
                    message.sgMonNum = object.sgMonNum | 0;
                if (object.shipinGoldNum != null)
                    message.shipinGoldNum = object.shipinGoldNum | 0;
                if (object.physicalCapacity != null)
                    message.physicalCapacity = object.physicalCapacity | 0;
                if (object.todayJumpNum != null)
                    message.todayJumpNum = object.todayJumpNum | 0;
                if (object.todayZhNum != null)
                    message.todayZhNum = object.todayZhNum | 0;
                return message;
            };

            /**
             * Creates a plain object from a playerInfoRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.playerInfoRet
             * @static
             * @param {msg.info.playerInfoRet} message playerInfoRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            playerInfoRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.passNum = 0;
                    object.money = "";
                    object.hongbao = 0;
                    object.turntableTimes = 0;
                    object.nextOnlineHongbaoTime = 0;
                    object.onlineHongbaoValue = 0;
                    object.bossHongbaoNum = 0;
                    object.todayAdMoney = 0;
                    object.zwHongbaoNum = 0;
                    object.sgHongbaoNum = 0;
                    object.sgMonNum = 0;
                    object.shipinGoldNum = 0;
                    object.physicalCapacity = 0;
                    object.todayJumpNum = 0;
                    object.todayZhNum = 0;
                }
                if (message.passNum != null && message.hasOwnProperty("passNum"))
                    object.passNum = message.passNum;
                if (message.money != null && message.hasOwnProperty("money"))
                    object.money = message.money;
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    object.hongbao = message.hongbao;
                if (message.turntableTimes != null && message.hasOwnProperty("turntableTimes"))
                    object.turntableTimes = message.turntableTimes;
                if (message.nextOnlineHongbaoTime != null && message.hasOwnProperty("nextOnlineHongbaoTime"))
                    object.nextOnlineHongbaoTime = message.nextOnlineHongbaoTime;
                if (message.onlineHongbaoValue != null && message.hasOwnProperty("onlineHongbaoValue"))
                    object.onlineHongbaoValue = message.onlineHongbaoValue;
                if (message.bossHongbaoNum != null && message.hasOwnProperty("bossHongbaoNum"))
                    object.bossHongbaoNum = message.bossHongbaoNum;
                if (message.todayAdMoney != null && message.hasOwnProperty("todayAdMoney"))
                    object.todayAdMoney = message.todayAdMoney;
                if (message.zwHongbaoNum != null && message.hasOwnProperty("zwHongbaoNum"))
                    object.zwHongbaoNum = message.zwHongbaoNum;
                if (message.sgHongbaoNum != null && message.hasOwnProperty("sgHongbaoNum"))
                    object.sgHongbaoNum = message.sgHongbaoNum;
                if (message.sgMonNum != null && message.hasOwnProperty("sgMonNum"))
                    object.sgMonNum = message.sgMonNum;
                if (message.shipinGoldNum != null && message.hasOwnProperty("shipinGoldNum"))
                    object.shipinGoldNum = message.shipinGoldNum;
                if (message.physicalCapacity != null && message.hasOwnProperty("physicalCapacity"))
                    object.physicalCapacity = message.physicalCapacity;
                if (message.todayJumpNum != null && message.hasOwnProperty("todayJumpNum"))
                    object.todayJumpNum = message.todayJumpNum;
                if (message.todayZhNum != null && message.hasOwnProperty("todayZhNum"))
                    object.todayZhNum = message.todayZhNum;
                return object;
            };

            /**
             * Converts this playerInfoRet to JSON.
             * @function toJSON
             * @memberof msg.info.playerInfoRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            playerInfoRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return playerInfoRet;
        })();

        info.signListRet = (function() {

            /**
             * Properties of a signListRet.
             * @memberof msg.info
             * @interface IsignListRet
             * @property {number|null} [todaySign] signListRet todaySign
             * @property {number|null} [signDay] signListRet signDay
             */

            /**
             * Constructs a new signListRet.
             * @memberof msg.info
             * @classdesc Represents a signListRet.
             * @implements IsignListRet
             * @constructor
             * @param {msg.info.IsignListRet=} [properties] Properties to set
             */
            function signListRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * signListRet todaySign.
             * @member {number} todaySign
             * @memberof msg.info.signListRet
             * @instance
             */
            signListRet.prototype.todaySign = 0;

            /**
             * signListRet signDay.
             * @member {number} signDay
             * @memberof msg.info.signListRet
             * @instance
             */
            signListRet.prototype.signDay = 0;

            /**
             * Creates a new signListRet instance using the specified properties.
             * @function create
             * @memberof msg.info.signListRet
             * @static
             * @param {msg.info.IsignListRet=} [properties] Properties to set
             * @returns {msg.info.signListRet} signListRet instance
             */
            signListRet.create = function create(properties) {
                return new signListRet(properties);
            };

            /**
             * Encodes the specified signListRet message. Does not implicitly {@link msg.info.signListRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.signListRet
             * @static
             * @param {msg.info.IsignListRet} message signListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            signListRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.todaySign != null && Object.hasOwnProperty.call(message, "todaySign"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.todaySign);
                if (message.signDay != null && Object.hasOwnProperty.call(message, "signDay"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.signDay);
                return writer;
            };

            /**
             * Encodes the specified signListRet message, length delimited. Does not implicitly {@link msg.info.signListRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.signListRet
             * @static
             * @param {msg.info.IsignListRet} message signListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            signListRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a signListRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.signListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.signListRet} signListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            signListRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.signListRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.todaySign = reader.int32();
                        break;
                    case 2:
                        message.signDay = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a signListRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.signListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.signListRet} signListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            signListRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a signListRet message.
             * @function verify
             * @memberof msg.info.signListRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            signListRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.todaySign != null && message.hasOwnProperty("todaySign"))
                    if (!$util.isInteger(message.todaySign))
                        return "todaySign: integer expected";
                if (message.signDay != null && message.hasOwnProperty("signDay"))
                    if (!$util.isInteger(message.signDay))
                        return "signDay: integer expected";
                return null;
            };

            /**
             * Creates a signListRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.signListRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.signListRet} signListRet
             */
            signListRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.signListRet)
                    return object;
                var message = new $root.msg.info.signListRet();
                if (object.todaySign != null)
                    message.todaySign = object.todaySign | 0;
                if (object.signDay != null)
                    message.signDay = object.signDay | 0;
                return message;
            };

            /**
             * Creates a plain object from a signListRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.signListRet
             * @static
             * @param {msg.info.signListRet} message signListRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            signListRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.todaySign = 0;
                    object.signDay = 0;
                }
                if (message.todaySign != null && message.hasOwnProperty("todaySign"))
                    object.todaySign = message.todaySign;
                if (message.signDay != null && message.hasOwnProperty("signDay"))
                    object.signDay = message.signDay;
                return object;
            };

            /**
             * Converts this signListRet to JSON.
             * @function toJSON
             * @memberof msg.info.signListRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            signListRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return signListRet;
        })();

        info.taskListRet = (function() {

            /**
             * Properties of a taskListRet.
             * @memberof msg.info
             * @interface ItaskListRet
             * @property {number|null} [day] taskListRet day
             * @property {number|null} [taskProgress] taskListRet taskProgress
             * @property {number|null} [isProgressCash_5] taskListRet isProgressCash_5
             * @property {Array.<msg.info.ITask>|null} [taskList] taskListRet taskList
             */

            /**
             * Constructs a new taskListRet.
             * @memberof msg.info
             * @classdesc Represents a taskListRet.
             * @implements ItaskListRet
             * @constructor
             * @param {msg.info.ItaskListRet=} [properties] Properties to set
             */
            function taskListRet(properties) {
                this.taskList = [];
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * taskListRet day.
             * @member {number} day
             * @memberof msg.info.taskListRet
             * @instance
             */
            taskListRet.prototype.day = 0;

            /**
             * taskListRet taskProgress.
             * @member {number} taskProgress
             * @memberof msg.info.taskListRet
             * @instance
             */
            taskListRet.prototype.taskProgress = 0;

            /**
             * taskListRet isProgressCash_5.
             * @member {number} isProgressCash_5
             * @memberof msg.info.taskListRet
             * @instance
             */
            taskListRet.prototype.isProgressCash_5 = 0;

            /**
             * taskListRet taskList.
             * @member {Array.<msg.info.ITask>} taskList
             * @memberof msg.info.taskListRet
             * @instance
             */
            taskListRet.prototype.taskList = $util.emptyArray;

            /**
             * Creates a new taskListRet instance using the specified properties.
             * @function create
             * @memberof msg.info.taskListRet
             * @static
             * @param {msg.info.ItaskListRet=} [properties] Properties to set
             * @returns {msg.info.taskListRet} taskListRet instance
             */
            taskListRet.create = function create(properties) {
                return new taskListRet(properties);
            };

            /**
             * Encodes the specified taskListRet message. Does not implicitly {@link msg.info.taskListRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.taskListRet
             * @static
             * @param {msg.info.ItaskListRet} message taskListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            taskListRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.day != null && Object.hasOwnProperty.call(message, "day"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.day);
                if (message.taskProgress != null && Object.hasOwnProperty.call(message, "taskProgress"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.taskProgress);
                if (message.isProgressCash_5 != null && Object.hasOwnProperty.call(message, "isProgressCash_5"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.isProgressCash_5);
                if (message.taskList != null && message.taskList.length)
                    for (var i = 0; i < message.taskList.length; ++i)
                        $root.msg.info.Task.encode(message.taskList[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
                return writer;
            };

            /**
             * Encodes the specified taskListRet message, length delimited. Does not implicitly {@link msg.info.taskListRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.taskListRet
             * @static
             * @param {msg.info.ItaskListRet} message taskListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            taskListRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a taskListRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.taskListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.taskListRet} taskListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            taskListRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.taskListRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.day = reader.int32();
                        break;
                    case 2:
                        message.taskProgress = reader.int32();
                        break;
                    case 3:
                        message.isProgressCash_5 = reader.int32();
                        break;
                    case 4:
                        if (!(message.taskList && message.taskList.length))
                            message.taskList = [];
                        message.taskList.push($root.msg.info.Task.decode(reader, reader.uint32()));
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a taskListRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.taskListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.taskListRet} taskListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            taskListRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a taskListRet message.
             * @function verify
             * @memberof msg.info.taskListRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            taskListRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.day != null && message.hasOwnProperty("day"))
                    if (!$util.isInteger(message.day))
                        return "day: integer expected";
                if (message.taskProgress != null && message.hasOwnProperty("taskProgress"))
                    if (!$util.isInteger(message.taskProgress))
                        return "taskProgress: integer expected";
                if (message.isProgressCash_5 != null && message.hasOwnProperty("isProgressCash_5"))
                    if (!$util.isInteger(message.isProgressCash_5))
                        return "isProgressCash_5: integer expected";
                if (message.taskList != null && message.hasOwnProperty("taskList")) {
                    if (!Array.isArray(message.taskList))
                        return "taskList: array expected";
                    for (var i = 0; i < message.taskList.length; ++i) {
                        var error = $root.msg.info.Task.verify(message.taskList[i]);
                        if (error)
                            return "taskList." + error;
                    }
                }
                return null;
            };

            /**
             * Creates a taskListRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.taskListRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.taskListRet} taskListRet
             */
            taskListRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.taskListRet)
                    return object;
                var message = new $root.msg.info.taskListRet();
                if (object.day != null)
                    message.day = object.day | 0;
                if (object.taskProgress != null)
                    message.taskProgress = object.taskProgress | 0;
                if (object.isProgressCash_5 != null)
                    message.isProgressCash_5 = object.isProgressCash_5 | 0;
                if (object.taskList) {
                    if (!Array.isArray(object.taskList))
                        throw TypeError(".msg.info.taskListRet.taskList: array expected");
                    message.taskList = [];
                    for (var i = 0; i < object.taskList.length; ++i) {
                        if (typeof object.taskList[i] !== "object")
                            throw TypeError(".msg.info.taskListRet.taskList: object expected");
                        message.taskList[i] = $root.msg.info.Task.fromObject(object.taskList[i]);
                    }
                }
                return message;
            };

            /**
             * Creates a plain object from a taskListRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.taskListRet
             * @static
             * @param {msg.info.taskListRet} message taskListRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            taskListRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.arrays || options.defaults)
                    object.taskList = [];
                if (options.defaults) {
                    object.day = 0;
                    object.taskProgress = 0;
                    object.isProgressCash_5 = 0;
                }
                if (message.day != null && message.hasOwnProperty("day"))
                    object.day = message.day;
                if (message.taskProgress != null && message.hasOwnProperty("taskProgress"))
                    object.taskProgress = message.taskProgress;
                if (message.isProgressCash_5 != null && message.hasOwnProperty("isProgressCash_5"))
                    object.isProgressCash_5 = message.isProgressCash_5;
                if (message.taskList && message.taskList.length) {
                    object.taskList = [];
                    for (var j = 0; j < message.taskList.length; ++j)
                        object.taskList[j] = $root.msg.info.Task.toObject(message.taskList[j], options);
                }
                return object;
            };

            /**
             * Converts this taskListRet to JSON.
             * @function toJSON
             * @memberof msg.info.taskListRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            taskListRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return taskListRet;
        })();

        info.raffleListRet = (function() {

            /**
             * Properties of a raffleListRet.
             * @memberof msg.info
             * @interface IraffleListRet
             * @property {number|null} [accPass] raffleListRet accPass
             * @property {number|null} [maxPass] raffleListRet maxPass
             * @property {Array.<msg.info.IChance>|null} [chanceList] raffleListRet chanceList
             */

            /**
             * Constructs a new raffleListRet.
             * @memberof msg.info
             * @classdesc Represents a raffleListRet.
             * @implements IraffleListRet
             * @constructor
             * @param {msg.info.IraffleListRet=} [properties] Properties to set
             */
            function raffleListRet(properties) {
                this.chanceList = [];
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * raffleListRet accPass.
             * @member {number} accPass
             * @memberof msg.info.raffleListRet
             * @instance
             */
            raffleListRet.prototype.accPass = 0;

            /**
             * raffleListRet maxPass.
             * @member {number} maxPass
             * @memberof msg.info.raffleListRet
             * @instance
             */
            raffleListRet.prototype.maxPass = 0;

            /**
             * raffleListRet chanceList.
             * @member {Array.<msg.info.IChance>} chanceList
             * @memberof msg.info.raffleListRet
             * @instance
             */
            raffleListRet.prototype.chanceList = $util.emptyArray;

            /**
             * Creates a new raffleListRet instance using the specified properties.
             * @function create
             * @memberof msg.info.raffleListRet
             * @static
             * @param {msg.info.IraffleListRet=} [properties] Properties to set
             * @returns {msg.info.raffleListRet} raffleListRet instance
             */
            raffleListRet.create = function create(properties) {
                return new raffleListRet(properties);
            };

            /**
             * Encodes the specified raffleListRet message. Does not implicitly {@link msg.info.raffleListRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.raffleListRet
             * @static
             * @param {msg.info.IraffleListRet} message raffleListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            raffleListRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.accPass != null && Object.hasOwnProperty.call(message, "accPass"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.accPass);
                if (message.maxPass != null && Object.hasOwnProperty.call(message, "maxPass"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.maxPass);
                if (message.chanceList != null && message.chanceList.length)
                    for (var i = 0; i < message.chanceList.length; ++i)
                        $root.msg.info.Chance.encode(message.chanceList[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
                return writer;
            };

            /**
             * Encodes the specified raffleListRet message, length delimited. Does not implicitly {@link msg.info.raffleListRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.raffleListRet
             * @static
             * @param {msg.info.IraffleListRet} message raffleListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            raffleListRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a raffleListRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.raffleListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.raffleListRet} raffleListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            raffleListRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.raffleListRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.accPass = reader.int32();
                        break;
                    case 2:
                        message.maxPass = reader.int32();
                        break;
                    case 3:
                        if (!(message.chanceList && message.chanceList.length))
                            message.chanceList = [];
                        message.chanceList.push($root.msg.info.Chance.decode(reader, reader.uint32()));
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a raffleListRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.raffleListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.raffleListRet} raffleListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            raffleListRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a raffleListRet message.
             * @function verify
             * @memberof msg.info.raffleListRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            raffleListRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.accPass != null && message.hasOwnProperty("accPass"))
                    if (!$util.isInteger(message.accPass))
                        return "accPass: integer expected";
                if (message.maxPass != null && message.hasOwnProperty("maxPass"))
                    if (!$util.isInteger(message.maxPass))
                        return "maxPass: integer expected";
                if (message.chanceList != null && message.hasOwnProperty("chanceList")) {
                    if (!Array.isArray(message.chanceList))
                        return "chanceList: array expected";
                    for (var i = 0; i < message.chanceList.length; ++i) {
                        var error = $root.msg.info.Chance.verify(message.chanceList[i]);
                        if (error)
                            return "chanceList." + error;
                    }
                }
                return null;
            };

            /**
             * Creates a raffleListRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.raffleListRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.raffleListRet} raffleListRet
             */
            raffleListRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.raffleListRet)
                    return object;
                var message = new $root.msg.info.raffleListRet();
                if (object.accPass != null)
                    message.accPass = object.accPass | 0;
                if (object.maxPass != null)
                    message.maxPass = object.maxPass | 0;
                if (object.chanceList) {
                    if (!Array.isArray(object.chanceList))
                        throw TypeError(".msg.info.raffleListRet.chanceList: array expected");
                    message.chanceList = [];
                    for (var i = 0; i < object.chanceList.length; ++i) {
                        if (typeof object.chanceList[i] !== "object")
                            throw TypeError(".msg.info.raffleListRet.chanceList: object expected");
                        message.chanceList[i] = $root.msg.info.Chance.fromObject(object.chanceList[i]);
                    }
                }
                return message;
            };

            /**
             * Creates a plain object from a raffleListRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.raffleListRet
             * @static
             * @param {msg.info.raffleListRet} message raffleListRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            raffleListRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.arrays || options.defaults)
                    object.chanceList = [];
                if (options.defaults) {
                    object.accPass = 0;
                    object.maxPass = 0;
                }
                if (message.accPass != null && message.hasOwnProperty("accPass"))
                    object.accPass = message.accPass;
                if (message.maxPass != null && message.hasOwnProperty("maxPass"))
                    object.maxPass = message.maxPass;
                if (message.chanceList && message.chanceList.length) {
                    object.chanceList = [];
                    for (var j = 0; j < message.chanceList.length; ++j)
                        object.chanceList[j] = $root.msg.info.Chance.toObject(message.chanceList[j], options);
                }
                return object;
            };

            /**
             * Converts this raffleListRet to JSON.
             * @function toJSON
             * @memberof msg.info.raffleListRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            raffleListRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return raffleListRet;
        })();

        info.Chance = (function() {

            /**
             * Properties of a Chance.
             * @memberof msg.info
             * @interface IChance
             * @property {number|null} [type] Chance type
             * @property {number|null} [lastTime] Chance lastTime
             * @property {string|null} [value] Chance value
             */

            /**
             * Constructs a new Chance.
             * @memberof msg.info
             * @classdesc Represents a Chance.
             * @implements IChance
             * @constructor
             * @param {msg.info.IChance=} [properties] Properties to set
             */
            function Chance(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * Chance type.
             * @member {number} type
             * @memberof msg.info.Chance
             * @instance
             */
            Chance.prototype.type = 0;

            /**
             * Chance lastTime.
             * @member {number} lastTime
             * @memberof msg.info.Chance
             * @instance
             */
            Chance.prototype.lastTime = 0;

            /**
             * Chance value.
             * @member {string} value
             * @memberof msg.info.Chance
             * @instance
             */
            Chance.prototype.value = "";

            /**
             * Creates a new Chance instance using the specified properties.
             * @function create
             * @memberof msg.info.Chance
             * @static
             * @param {msg.info.IChance=} [properties] Properties to set
             * @returns {msg.info.Chance} Chance instance
             */
            Chance.create = function create(properties) {
                return new Chance(properties);
            };

            /**
             * Encodes the specified Chance message. Does not implicitly {@link msg.info.Chance.verify|verify} messages.
             * @function encode
             * @memberof msg.info.Chance
             * @static
             * @param {msg.info.IChance} message Chance message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Chance.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.lastTime != null && Object.hasOwnProperty.call(message, "lastTime"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.lastTime);
                if (message.value != null && Object.hasOwnProperty.call(message, "value"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.value);
                return writer;
            };

            /**
             * Encodes the specified Chance message, length delimited. Does not implicitly {@link msg.info.Chance.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.Chance
             * @static
             * @param {msg.info.IChance} message Chance message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Chance.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a Chance message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.Chance
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.Chance} Chance
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Chance.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.Chance();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.lastTime = reader.int32();
                        break;
                    case 3:
                        message.value = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a Chance message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.Chance
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.Chance} Chance
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Chance.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a Chance message.
             * @function verify
             * @memberof msg.info.Chance
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            Chance.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.lastTime != null && message.hasOwnProperty("lastTime"))
                    if (!$util.isInteger(message.lastTime))
                        return "lastTime: integer expected";
                if (message.value != null && message.hasOwnProperty("value"))
                    if (!$util.isString(message.value))
                        return "value: string expected";
                return null;
            };

            /**
             * Creates a Chance message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.Chance
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.Chance} Chance
             */
            Chance.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.Chance)
                    return object;
                var message = new $root.msg.info.Chance();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.lastTime != null)
                    message.lastTime = object.lastTime | 0;
                if (object.value != null)
                    message.value = String(object.value);
                return message;
            };

            /**
             * Creates a plain object from a Chance message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.Chance
             * @static
             * @param {msg.info.Chance} message Chance
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            Chance.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.lastTime = 0;
                    object.value = "";
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.lastTime != null && message.hasOwnProperty("lastTime"))
                    object.lastTime = message.lastTime;
                if (message.value != null && message.hasOwnProperty("value"))
                    object.value = message.value;
                return object;
            };

            /**
             * Converts this Chance to JSON.
             * @function toJSON
             * @memberof msg.info.Chance
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            Chance.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return Chance;
        })();

        info.Task = (function() {

            /**
             * Properties of a Task.
             * @memberof msg.info
             * @interface ITask
             * @property {number|null} [taskGroup] Task taskGroup
             * @property {number|null} [taskId] Task taskId
             * @property {number|null} [index] Task index
             * @property {number|null} [value] Task value
             * @property {number|null} [state] Task state
             */

            /**
             * Constructs a new Task.
             * @memberof msg.info
             * @classdesc Represents a Task.
             * @implements ITask
             * @constructor
             * @param {msg.info.ITask=} [properties] Properties to set
             */
            function Task(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * Task taskGroup.
             * @member {number} taskGroup
             * @memberof msg.info.Task
             * @instance
             */
            Task.prototype.taskGroup = 0;

            /**
             * Task taskId.
             * @member {number} taskId
             * @memberof msg.info.Task
             * @instance
             */
            Task.prototype.taskId = 0;

            /**
             * Task index.
             * @member {number} index
             * @memberof msg.info.Task
             * @instance
             */
            Task.prototype.index = 0;

            /**
             * Task value.
             * @member {number} value
             * @memberof msg.info.Task
             * @instance
             */
            Task.prototype.value = 0;

            /**
             * Task state.
             * @member {number} state
             * @memberof msg.info.Task
             * @instance
             */
            Task.prototype.state = 0;

            /**
             * Creates a new Task instance using the specified properties.
             * @function create
             * @memberof msg.info.Task
             * @static
             * @param {msg.info.ITask=} [properties] Properties to set
             * @returns {msg.info.Task} Task instance
             */
            Task.create = function create(properties) {
                return new Task(properties);
            };

            /**
             * Encodes the specified Task message. Does not implicitly {@link msg.info.Task.verify|verify} messages.
             * @function encode
             * @memberof msg.info.Task
             * @static
             * @param {msg.info.ITask} message Task message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Task.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.taskGroup != null && Object.hasOwnProperty.call(message, "taskGroup"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.taskGroup);
                if (message.taskId != null && Object.hasOwnProperty.call(message, "taskId"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.taskId);
                if (message.index != null && Object.hasOwnProperty.call(message, "index"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.index);
                if (message.value != null && Object.hasOwnProperty.call(message, "value"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.value);
                if (message.state != null && Object.hasOwnProperty.call(message, "state"))
                    writer.uint32(/* id 5, wireType 0 =*/40).int32(message.state);
                return writer;
            };

            /**
             * Encodes the specified Task message, length delimited. Does not implicitly {@link msg.info.Task.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.Task
             * @static
             * @param {msg.info.ITask} message Task message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Task.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a Task message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.Task
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.Task} Task
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Task.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.Task();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.taskGroup = reader.int32();
                        break;
                    case 2:
                        message.taskId = reader.int32();
                        break;
                    case 3:
                        message.index = reader.int32();
                        break;
                    case 4:
                        message.value = reader.int32();
                        break;
                    case 5:
                        message.state = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a Task message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.Task
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.Task} Task
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Task.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a Task message.
             * @function verify
             * @memberof msg.info.Task
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            Task.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.taskGroup != null && message.hasOwnProperty("taskGroup"))
                    if (!$util.isInteger(message.taskGroup))
                        return "taskGroup: integer expected";
                if (message.taskId != null && message.hasOwnProperty("taskId"))
                    if (!$util.isInteger(message.taskId))
                        return "taskId: integer expected";
                if (message.index != null && message.hasOwnProperty("index"))
                    if (!$util.isInteger(message.index))
                        return "index: integer expected";
                if (message.value != null && message.hasOwnProperty("value"))
                    if (!$util.isInteger(message.value))
                        return "value: integer expected";
                if (message.state != null && message.hasOwnProperty("state"))
                    if (!$util.isInteger(message.state))
                        return "state: integer expected";
                return null;
            };

            /**
             * Creates a Task message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.Task
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.Task} Task
             */
            Task.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.Task)
                    return object;
                var message = new $root.msg.info.Task();
                if (object.taskGroup != null)
                    message.taskGroup = object.taskGroup | 0;
                if (object.taskId != null)
                    message.taskId = object.taskId | 0;
                if (object.index != null)
                    message.index = object.index | 0;
                if (object.value != null)
                    message.value = object.value | 0;
                if (object.state != null)
                    message.state = object.state | 0;
                return message;
            };

            /**
             * Creates a plain object from a Task message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.Task
             * @static
             * @param {msg.info.Task} message Task
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            Task.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.taskGroup = 0;
                    object.taskId = 0;
                    object.index = 0;
                    object.value = 0;
                    object.state = 0;
                }
                if (message.taskGroup != null && message.hasOwnProperty("taskGroup"))
                    object.taskGroup = message.taskGroup;
                if (message.taskId != null && message.hasOwnProperty("taskId"))
                    object.taskId = message.taskId;
                if (message.index != null && message.hasOwnProperty("index"))
                    object.index = message.index;
                if (message.value != null && message.hasOwnProperty("value"))
                    object.value = message.value;
                if (message.state != null && message.hasOwnProperty("state"))
                    object.state = message.state;
                return object;
            };

            /**
             * Converts this Task to JSON.
             * @function toJSON
             * @memberof msg.info.Task
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            Task.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return Task;
        })();

        info.dividendRet = (function() {

            /**
             * Properties of a dividendRet.
             * @memberof msg.info
             * @interface IdividendRet
             * @property {number|null} [pigLevel] dividendRet pigLevel
             * @property {number|null} [pigExp] dividendRet pigExp
             * @property {number|null} [pigGold] dividendRet pigGold
             * @property {number|null} [todayPigGoldNum] dividendRet todayPigGoldNum
             * @property {number|null} [yesterdayIncome] dividendRet yesterdayIncome
             * @property {number|null} [historyIncome] dividendRet historyIncome
             * @property {Array.<msg.info.IdividendPlayer>|null} [playerList] dividendRet playerList
             */

            /**
             * Constructs a new dividendRet.
             * @memberof msg.info
             * @classdesc Represents a dividendRet.
             * @implements IdividendRet
             * @constructor
             * @param {msg.info.IdividendRet=} [properties] Properties to set
             */
            function dividendRet(properties) {
                this.playerList = [];
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * dividendRet pigLevel.
             * @member {number} pigLevel
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.pigLevel = 0;

            /**
             * dividendRet pigExp.
             * @member {number} pigExp
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.pigExp = 0;

            /**
             * dividendRet pigGold.
             * @member {number} pigGold
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.pigGold = 0;

            /**
             * dividendRet todayPigGoldNum.
             * @member {number} todayPigGoldNum
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.todayPigGoldNum = 0;

            /**
             * dividendRet yesterdayIncome.
             * @member {number} yesterdayIncome
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.yesterdayIncome = 0;

            /**
             * dividendRet historyIncome.
             * @member {number} historyIncome
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.historyIncome = 0;

            /**
             * dividendRet playerList.
             * @member {Array.<msg.info.IdividendPlayer>} playerList
             * @memberof msg.info.dividendRet
             * @instance
             */
            dividendRet.prototype.playerList = $util.emptyArray;

            /**
             * Creates a new dividendRet instance using the specified properties.
             * @function create
             * @memberof msg.info.dividendRet
             * @static
             * @param {msg.info.IdividendRet=} [properties] Properties to set
             * @returns {msg.info.dividendRet} dividendRet instance
             */
            dividendRet.create = function create(properties) {
                return new dividendRet(properties);
            };

            /**
             * Encodes the specified dividendRet message. Does not implicitly {@link msg.info.dividendRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.dividendRet
             * @static
             * @param {msg.info.IdividendRet} message dividendRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            dividendRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.pigLevel != null && Object.hasOwnProperty.call(message, "pigLevel"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.pigLevel);
                if (message.pigExp != null && Object.hasOwnProperty.call(message, "pigExp"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.pigExp);
                if (message.pigGold != null && Object.hasOwnProperty.call(message, "pigGold"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.pigGold);
                if (message.todayPigGoldNum != null && Object.hasOwnProperty.call(message, "todayPigGoldNum"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.todayPigGoldNum);
                if (message.yesterdayIncome != null && Object.hasOwnProperty.call(message, "yesterdayIncome"))
                    writer.uint32(/* id 5, wireType 5 =*/45).float(message.yesterdayIncome);
                if (message.historyIncome != null && Object.hasOwnProperty.call(message, "historyIncome"))
                    writer.uint32(/* id 6, wireType 5 =*/53).float(message.historyIncome);
                if (message.playerList != null && message.playerList.length)
                    for (var i = 0; i < message.playerList.length; ++i)
                        $root.msg.info.dividendPlayer.encode(message.playerList[i], writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
                return writer;
            };

            /**
             * Encodes the specified dividendRet message, length delimited. Does not implicitly {@link msg.info.dividendRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.dividendRet
             * @static
             * @param {msg.info.IdividendRet} message dividendRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            dividendRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a dividendRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.dividendRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.dividendRet} dividendRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            dividendRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.dividendRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.pigLevel = reader.int32();
                        break;
                    case 2:
                        message.pigExp = reader.int32();
                        break;
                    case 3:
                        message.pigGold = reader.int32();
                        break;
                    case 4:
                        message.todayPigGoldNum = reader.int32();
                        break;
                    case 5:
                        message.yesterdayIncome = reader.float();
                        break;
                    case 6:
                        message.historyIncome = reader.float();
                        break;
                    case 7:
                        if (!(message.playerList && message.playerList.length))
                            message.playerList = [];
                        message.playerList.push($root.msg.info.dividendPlayer.decode(reader, reader.uint32()));
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a dividendRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.dividendRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.dividendRet} dividendRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            dividendRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a dividendRet message.
             * @function verify
             * @memberof msg.info.dividendRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            dividendRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.pigLevel != null && message.hasOwnProperty("pigLevel"))
                    if (!$util.isInteger(message.pigLevel))
                        return "pigLevel: integer expected";
                if (message.pigExp != null && message.hasOwnProperty("pigExp"))
                    if (!$util.isInteger(message.pigExp))
                        return "pigExp: integer expected";
                if (message.pigGold != null && message.hasOwnProperty("pigGold"))
                    if (!$util.isInteger(message.pigGold))
                        return "pigGold: integer expected";
                if (message.todayPigGoldNum != null && message.hasOwnProperty("todayPigGoldNum"))
                    if (!$util.isInteger(message.todayPigGoldNum))
                        return "todayPigGoldNum: integer expected";
                if (message.yesterdayIncome != null && message.hasOwnProperty("yesterdayIncome"))
                    if (typeof message.yesterdayIncome !== "number")
                        return "yesterdayIncome: number expected";
                if (message.historyIncome != null && message.hasOwnProperty("historyIncome"))
                    if (typeof message.historyIncome !== "number")
                        return "historyIncome: number expected";
                if (message.playerList != null && message.hasOwnProperty("playerList")) {
                    if (!Array.isArray(message.playerList))
                        return "playerList: array expected";
                    for (var i = 0; i < message.playerList.length; ++i) {
                        var error = $root.msg.info.dividendPlayer.verify(message.playerList[i]);
                        if (error)
                            return "playerList." + error;
                    }
                }
                return null;
            };

            /**
             * Creates a dividendRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.dividendRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.dividendRet} dividendRet
             */
            dividendRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.dividendRet)
                    return object;
                var message = new $root.msg.info.dividendRet();
                if (object.pigLevel != null)
                    message.pigLevel = object.pigLevel | 0;
                if (object.pigExp != null)
                    message.pigExp = object.pigExp | 0;
                if (object.pigGold != null)
                    message.pigGold = object.pigGold | 0;
                if (object.todayPigGoldNum != null)
                    message.todayPigGoldNum = object.todayPigGoldNum | 0;
                if (object.yesterdayIncome != null)
                    message.yesterdayIncome = Number(object.yesterdayIncome);
                if (object.historyIncome != null)
                    message.historyIncome = Number(object.historyIncome);
                if (object.playerList) {
                    if (!Array.isArray(object.playerList))
                        throw TypeError(".msg.info.dividendRet.playerList: array expected");
                    message.playerList = [];
                    for (var i = 0; i < object.playerList.length; ++i) {
                        if (typeof object.playerList[i] !== "object")
                            throw TypeError(".msg.info.dividendRet.playerList: object expected");
                        message.playerList[i] = $root.msg.info.dividendPlayer.fromObject(object.playerList[i]);
                    }
                }
                return message;
            };

            /**
             * Creates a plain object from a dividendRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.dividendRet
             * @static
             * @param {msg.info.dividendRet} message dividendRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            dividendRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.arrays || options.defaults)
                    object.playerList = [];
                if (options.defaults) {
                    object.pigLevel = 0;
                    object.pigExp = 0;
                    object.pigGold = 0;
                    object.todayPigGoldNum = 0;
                    object.yesterdayIncome = 0;
                    object.historyIncome = 0;
                }
                if (message.pigLevel != null && message.hasOwnProperty("pigLevel"))
                    object.pigLevel = message.pigLevel;
                if (message.pigExp != null && message.hasOwnProperty("pigExp"))
                    object.pigExp = message.pigExp;
                if (message.pigGold != null && message.hasOwnProperty("pigGold"))
                    object.pigGold = message.pigGold;
                if (message.todayPigGoldNum != null && message.hasOwnProperty("todayPigGoldNum"))
                    object.todayPigGoldNum = message.todayPigGoldNum;
                if (message.yesterdayIncome != null && message.hasOwnProperty("yesterdayIncome"))
                    object.yesterdayIncome = options.json && !isFinite(message.yesterdayIncome) ? String(message.yesterdayIncome) : message.yesterdayIncome;
                if (message.historyIncome != null && message.hasOwnProperty("historyIncome"))
                    object.historyIncome = options.json && !isFinite(message.historyIncome) ? String(message.historyIncome) : message.historyIncome;
                if (message.playerList && message.playerList.length) {
                    object.playerList = [];
                    for (var j = 0; j < message.playerList.length; ++j)
                        object.playerList[j] = $root.msg.info.dividendPlayer.toObject(message.playerList[j], options);
                }
                return object;
            };

            /**
             * Converts this dividendRet to JSON.
             * @function toJSON
             * @memberof msg.info.dividendRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            dividendRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return dividendRet;
        })();

        info.dividendPlayer = (function() {

            /**
             * Properties of a dividendPlayer.
             * @memberof msg.info
             * @interface IdividendPlayer
             * @property {string|null} [name] dividendPlayer name
             * @property {number|Long|null} [time] dividendPlayer time
             */

            /**
             * Constructs a new dividendPlayer.
             * @memberof msg.info
             * @classdesc Represents a dividendPlayer.
             * @implements IdividendPlayer
             * @constructor
             * @param {msg.info.IdividendPlayer=} [properties] Properties to set
             */
            function dividendPlayer(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * dividendPlayer name.
             * @member {string} name
             * @memberof msg.info.dividendPlayer
             * @instance
             */
            dividendPlayer.prototype.name = "";

            /**
             * dividendPlayer time.
             * @member {number|Long} time
             * @memberof msg.info.dividendPlayer
             * @instance
             */
            dividendPlayer.prototype.time = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

            /**
             * Creates a new dividendPlayer instance using the specified properties.
             * @function create
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {msg.info.IdividendPlayer=} [properties] Properties to set
             * @returns {msg.info.dividendPlayer} dividendPlayer instance
             */
            dividendPlayer.create = function create(properties) {
                return new dividendPlayer(properties);
            };

            /**
             * Encodes the specified dividendPlayer message. Does not implicitly {@link msg.info.dividendPlayer.verify|verify} messages.
             * @function encode
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {msg.info.IdividendPlayer} message dividendPlayer message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            dividendPlayer.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
                if (message.time != null && Object.hasOwnProperty.call(message, "time"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int64(message.time);
                return writer;
            };

            /**
             * Encodes the specified dividendPlayer message, length delimited. Does not implicitly {@link msg.info.dividendPlayer.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {msg.info.IdividendPlayer} message dividendPlayer message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            dividendPlayer.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a dividendPlayer message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.dividendPlayer} dividendPlayer
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            dividendPlayer.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.dividendPlayer();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.name = reader.string();
                        break;
                    case 3:
                        message.time = reader.int64();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a dividendPlayer message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.dividendPlayer} dividendPlayer
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            dividendPlayer.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a dividendPlayer message.
             * @function verify
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            dividendPlayer.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.name != null && message.hasOwnProperty("name"))
                    if (!$util.isString(message.name))
                        return "name: string expected";
                if (message.time != null && message.hasOwnProperty("time"))
                    if (!$util.isInteger(message.time) && !(message.time && $util.isInteger(message.time.low) && $util.isInteger(message.time.high)))
                        return "time: integer|Long expected";
                return null;
            };

            /**
             * Creates a dividendPlayer message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.dividendPlayer} dividendPlayer
             */
            dividendPlayer.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.dividendPlayer)
                    return object;
                var message = new $root.msg.info.dividendPlayer();
                if (object.name != null)
                    message.name = String(object.name);
                if (object.time != null)
                    if ($util.Long)
                        (message.time = $util.Long.fromValue(object.time)).unsigned = false;
                    else if (typeof object.time === "string")
                        message.time = parseInt(object.time, 10);
                    else if (typeof object.time === "number")
                        message.time = object.time;
                    else if (typeof object.time === "object")
                        message.time = new $util.LongBits(object.time.low >>> 0, object.time.high >>> 0).toNumber();
                return message;
            };

            /**
             * Creates a plain object from a dividendPlayer message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.dividendPlayer
             * @static
             * @param {msg.info.dividendPlayer} message dividendPlayer
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            dividendPlayer.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.name = "";
                    if ($util.Long) {
                        var long = new $util.Long(0, 0, false);
                        object.time = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                    } else
                        object.time = options.longs === String ? "0" : 0;
                }
                if (message.name != null && message.hasOwnProperty("name"))
                    object.name = message.name;
                if (message.time != null && message.hasOwnProperty("time"))
                    if (typeof message.time === "number")
                        object.time = options.longs === String ? String(message.time) : message.time;
                    else
                        object.time = options.longs === String ? $util.Long.prototype.toString.call(message.time) : options.longs === Number ? new $util.LongBits(message.time.low >>> 0, message.time.high >>> 0).toNumber() : message.time;
                return object;
            };

            /**
             * Converts this dividendPlayer to JSON.
             * @function toJSON
             * @memberof msg.info.dividendPlayer
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            dividendPlayer.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return dividendPlayer;
        })();

        info.cashRecord = (function() {

            /**
             * Properties of a cashRecord.
             * @memberof msg.info
             * @interface IcashRecord
             * @property {number|null} [group] cashRecord group
             * @property {number|null} [cashGear] cashRecord cashGear
             * @property {number|Long|null} [time] cashRecord time
             */

            /**
             * Constructs a new cashRecord.
             * @memberof msg.info
             * @classdesc Represents a cashRecord.
             * @implements IcashRecord
             * @constructor
             * @param {msg.info.IcashRecord=} [properties] Properties to set
             */
            function cashRecord(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * cashRecord group.
             * @member {number} group
             * @memberof msg.info.cashRecord
             * @instance
             */
            cashRecord.prototype.group = 0;

            /**
             * cashRecord cashGear.
             * @member {number} cashGear
             * @memberof msg.info.cashRecord
             * @instance
             */
            cashRecord.prototype.cashGear = 0;

            /**
             * cashRecord time.
             * @member {number|Long} time
             * @memberof msg.info.cashRecord
             * @instance
             */
            cashRecord.prototype.time = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

            /**
             * Creates a new cashRecord instance using the specified properties.
             * @function create
             * @memberof msg.info.cashRecord
             * @static
             * @param {msg.info.IcashRecord=} [properties] Properties to set
             * @returns {msg.info.cashRecord} cashRecord instance
             */
            cashRecord.create = function create(properties) {
                return new cashRecord(properties);
            };

            /**
             * Encodes the specified cashRecord message. Does not implicitly {@link msg.info.cashRecord.verify|verify} messages.
             * @function encode
             * @memberof msg.info.cashRecord
             * @static
             * @param {msg.info.IcashRecord} message cashRecord message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashRecord.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.group != null && Object.hasOwnProperty.call(message, "group"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.group);
                if (message.cashGear != null && Object.hasOwnProperty.call(message, "cashGear"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.cashGear);
                if (message.time != null && Object.hasOwnProperty.call(message, "time"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int64(message.time);
                return writer;
            };

            /**
             * Encodes the specified cashRecord message, length delimited. Does not implicitly {@link msg.info.cashRecord.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.cashRecord
             * @static
             * @param {msg.info.IcashRecord} message cashRecord message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashRecord.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a cashRecord message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.cashRecord
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.cashRecord} cashRecord
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashRecord.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.cashRecord();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.group = reader.int32();
                        break;
                    case 2:
                        message.cashGear = reader.int32();
                        break;
                    case 3:
                        message.time = reader.int64();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a cashRecord message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.cashRecord
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.cashRecord} cashRecord
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashRecord.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a cashRecord message.
             * @function verify
             * @memberof msg.info.cashRecord
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            cashRecord.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.group != null && message.hasOwnProperty("group"))
                    if (!$util.isInteger(message.group))
                        return "group: integer expected";
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    if (!$util.isInteger(message.cashGear))
                        return "cashGear: integer expected";
                if (message.time != null && message.hasOwnProperty("time"))
                    if (!$util.isInteger(message.time) && !(message.time && $util.isInteger(message.time.low) && $util.isInteger(message.time.high)))
                        return "time: integer|Long expected";
                return null;
            };

            /**
             * Creates a cashRecord message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.cashRecord
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.cashRecord} cashRecord
             */
            cashRecord.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.cashRecord)
                    return object;
                var message = new $root.msg.info.cashRecord();
                if (object.group != null)
                    message.group = object.group | 0;
                if (object.cashGear != null)
                    message.cashGear = object.cashGear | 0;
                if (object.time != null)
                    if ($util.Long)
                        (message.time = $util.Long.fromValue(object.time)).unsigned = false;
                    else if (typeof object.time === "string")
                        message.time = parseInt(object.time, 10);
                    else if (typeof object.time === "number")
                        message.time = object.time;
                    else if (typeof object.time === "object")
                        message.time = new $util.LongBits(object.time.low >>> 0, object.time.high >>> 0).toNumber();
                return message;
            };

            /**
             * Creates a plain object from a cashRecord message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.cashRecord
             * @static
             * @param {msg.info.cashRecord} message cashRecord
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            cashRecord.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.group = 0;
                    object.cashGear = 0;
                    if ($util.Long) {
                        var long = new $util.Long(0, 0, false);
                        object.time = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
                    } else
                        object.time = options.longs === String ? "0" : 0;
                }
                if (message.group != null && message.hasOwnProperty("group"))
                    object.group = message.group;
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    object.cashGear = message.cashGear;
                if (message.time != null && message.hasOwnProperty("time"))
                    if (typeof message.time === "number")
                        object.time = options.longs === String ? String(message.time) : message.time;
                    else
                        object.time = options.longs === String ? $util.Long.prototype.toString.call(message.time) : options.longs === Number ? new $util.LongBits(message.time.low >>> 0, message.time.high >>> 0).toNumber() : message.time;
                return object;
            };

            /**
             * Converts this cashRecord to JSON.
             * @function toJSON
             * @memberof msg.info.cashRecord
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            cashRecord.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return cashRecord;
        })();

        info.cashInfo = (function() {

            /**
             * Properties of a cashInfo.
             * @memberof msg.info
             * @interface IcashInfo
             * @property {number|null} [group] cashInfo group
             * @property {number|null} [cashGear] cashInfo cashGear
             * @property {number|null} [isGot] cashInfo isGot
             * @property {number|null} [evenSign] cashInfo evenSign
             * @property {number|null} [todayIsSign] cashInfo todayIsSign
             * @property {number|null} [isFront] cashInfo isFront
             * @property {number|null} [times] cashInfo times
             */

            /**
             * Constructs a new cashInfo.
             * @memberof msg.info
             * @classdesc Represents a cashInfo.
             * @implements IcashInfo
             * @constructor
             * @param {msg.info.IcashInfo=} [properties] Properties to set
             */
            function cashInfo(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * cashInfo group.
             * @member {number} group
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.group = 0;

            /**
             * cashInfo cashGear.
             * @member {number} cashGear
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.cashGear = 0;

            /**
             * cashInfo isGot.
             * @member {number} isGot
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.isGot = 0;

            /**
             * cashInfo evenSign.
             * @member {number} evenSign
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.evenSign = 0;

            /**
             * cashInfo todayIsSign.
             * @member {number} todayIsSign
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.todayIsSign = 0;

            /**
             * cashInfo isFront.
             * @member {number} isFront
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.isFront = 0;

            /**
             * cashInfo times.
             * @member {number} times
             * @memberof msg.info.cashInfo
             * @instance
             */
            cashInfo.prototype.times = 0;

            /**
             * Creates a new cashInfo instance using the specified properties.
             * @function create
             * @memberof msg.info.cashInfo
             * @static
             * @param {msg.info.IcashInfo=} [properties] Properties to set
             * @returns {msg.info.cashInfo} cashInfo instance
             */
            cashInfo.create = function create(properties) {
                return new cashInfo(properties);
            };

            /**
             * Encodes the specified cashInfo message. Does not implicitly {@link msg.info.cashInfo.verify|verify} messages.
             * @function encode
             * @memberof msg.info.cashInfo
             * @static
             * @param {msg.info.IcashInfo} message cashInfo message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashInfo.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.group != null && Object.hasOwnProperty.call(message, "group"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.group);
                if (message.cashGear != null && Object.hasOwnProperty.call(message, "cashGear"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.cashGear);
                if (message.isGot != null && Object.hasOwnProperty.call(message, "isGot"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.isGot);
                if (message.evenSign != null && Object.hasOwnProperty.call(message, "evenSign"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.evenSign);
                if (message.todayIsSign != null && Object.hasOwnProperty.call(message, "todayIsSign"))
                    writer.uint32(/* id 5, wireType 0 =*/40).int32(message.todayIsSign);
                if (message.isFront != null && Object.hasOwnProperty.call(message, "isFront"))
                    writer.uint32(/* id 6, wireType 0 =*/48).int32(message.isFront);
                if (message.times != null && Object.hasOwnProperty.call(message, "times"))
                    writer.uint32(/* id 7, wireType 0 =*/56).int32(message.times);
                return writer;
            };

            /**
             * Encodes the specified cashInfo message, length delimited. Does not implicitly {@link msg.info.cashInfo.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.cashInfo
             * @static
             * @param {msg.info.IcashInfo} message cashInfo message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashInfo.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a cashInfo message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.cashInfo
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.cashInfo} cashInfo
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashInfo.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.cashInfo();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.group = reader.int32();
                        break;
                    case 2:
                        message.cashGear = reader.int32();
                        break;
                    case 3:
                        message.isGot = reader.int32();
                        break;
                    case 4:
                        message.evenSign = reader.int32();
                        break;
                    case 5:
                        message.todayIsSign = reader.int32();
                        break;
                    case 6:
                        message.isFront = reader.int32();
                        break;
                    case 7:
                        message.times = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a cashInfo message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.cashInfo
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.cashInfo} cashInfo
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashInfo.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a cashInfo message.
             * @function verify
             * @memberof msg.info.cashInfo
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            cashInfo.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.group != null && message.hasOwnProperty("group"))
                    if (!$util.isInteger(message.group))
                        return "group: integer expected";
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    if (!$util.isInteger(message.cashGear))
                        return "cashGear: integer expected";
                if (message.isGot != null && message.hasOwnProperty("isGot"))
                    if (!$util.isInteger(message.isGot))
                        return "isGot: integer expected";
                if (message.evenSign != null && message.hasOwnProperty("evenSign"))
                    if (!$util.isInteger(message.evenSign))
                        return "evenSign: integer expected";
                if (message.todayIsSign != null && message.hasOwnProperty("todayIsSign"))
                    if (!$util.isInteger(message.todayIsSign))
                        return "todayIsSign: integer expected";
                if (message.isFront != null && message.hasOwnProperty("isFront"))
                    if (!$util.isInteger(message.isFront))
                        return "isFront: integer expected";
                if (message.times != null && message.hasOwnProperty("times"))
                    if (!$util.isInteger(message.times))
                        return "times: integer expected";
                return null;
            };

            /**
             * Creates a cashInfo message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.cashInfo
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.cashInfo} cashInfo
             */
            cashInfo.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.cashInfo)
                    return object;
                var message = new $root.msg.info.cashInfo();
                if (object.group != null)
                    message.group = object.group | 0;
                if (object.cashGear != null)
                    message.cashGear = object.cashGear | 0;
                if (object.isGot != null)
                    message.isGot = object.isGot | 0;
                if (object.evenSign != null)
                    message.evenSign = object.evenSign | 0;
                if (object.todayIsSign != null)
                    message.todayIsSign = object.todayIsSign | 0;
                if (object.isFront != null)
                    message.isFront = object.isFront | 0;
                if (object.times != null)
                    message.times = object.times | 0;
                return message;
            };

            /**
             * Creates a plain object from a cashInfo message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.cashInfo
             * @static
             * @param {msg.info.cashInfo} message cashInfo
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            cashInfo.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.group = 0;
                    object.cashGear = 0;
                    object.isGot = 0;
                    object.evenSign = 0;
                    object.todayIsSign = 0;
                    object.isFront = 0;
                    object.times = 0;
                }
                if (message.group != null && message.hasOwnProperty("group"))
                    object.group = message.group;
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    object.cashGear = message.cashGear;
                if (message.isGot != null && message.hasOwnProperty("isGot"))
                    object.isGot = message.isGot;
                if (message.evenSign != null && message.hasOwnProperty("evenSign"))
                    object.evenSign = message.evenSign;
                if (message.todayIsSign != null && message.hasOwnProperty("todayIsSign"))
                    object.todayIsSign = message.todayIsSign;
                if (message.isFront != null && message.hasOwnProperty("isFront"))
                    object.isFront = message.isFront;
                if (message.times != null && message.hasOwnProperty("times"))
                    object.times = message.times;
                return object;
            };

            /**
             * Converts this cashInfo to JSON.
             * @function toJSON
             * @memberof msg.info.cashInfo
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            cashInfo.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return cashInfo;
        })();

        info.cashInfoRet = (function() {

            /**
             * Properties of a cashInfoRet.
             * @memberof msg.info
             * @interface IcashInfoRet
             * @property {number|null} [friendNum] cashInfoRet friendNum
             * @property {Array.<msg.info.IcashInfo>|null} [cashInfoList] cashInfoRet cashInfoList
             */

            /**
             * Constructs a new cashInfoRet.
             * @memberof msg.info
             * @classdesc Represents a cashInfoRet.
             * @implements IcashInfoRet
             * @constructor
             * @param {msg.info.IcashInfoRet=} [properties] Properties to set
             */
            function cashInfoRet(properties) {
                this.cashInfoList = [];
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * cashInfoRet friendNum.
             * @member {number} friendNum
             * @memberof msg.info.cashInfoRet
             * @instance
             */
            cashInfoRet.prototype.friendNum = 0;

            /**
             * cashInfoRet cashInfoList.
             * @member {Array.<msg.info.IcashInfo>} cashInfoList
             * @memberof msg.info.cashInfoRet
             * @instance
             */
            cashInfoRet.prototype.cashInfoList = $util.emptyArray;

            /**
             * Creates a new cashInfoRet instance using the specified properties.
             * @function create
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {msg.info.IcashInfoRet=} [properties] Properties to set
             * @returns {msg.info.cashInfoRet} cashInfoRet instance
             */
            cashInfoRet.create = function create(properties) {
                return new cashInfoRet(properties);
            };

            /**
             * Encodes the specified cashInfoRet message. Does not implicitly {@link msg.info.cashInfoRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {msg.info.IcashInfoRet} message cashInfoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashInfoRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.friendNum != null && Object.hasOwnProperty.call(message, "friendNum"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.friendNum);
                if (message.cashInfoList != null && message.cashInfoList.length)
                    for (var i = 0; i < message.cashInfoList.length; ++i)
                        $root.msg.info.cashInfo.encode(message.cashInfoList[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
                return writer;
            };

            /**
             * Encodes the specified cashInfoRet message, length delimited. Does not implicitly {@link msg.info.cashInfoRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {msg.info.IcashInfoRet} message cashInfoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashInfoRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a cashInfoRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.cashInfoRet} cashInfoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashInfoRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.cashInfoRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.friendNum = reader.int32();
                        break;
                    case 2:
                        if (!(message.cashInfoList && message.cashInfoList.length))
                            message.cashInfoList = [];
                        message.cashInfoList.push($root.msg.info.cashInfo.decode(reader, reader.uint32()));
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a cashInfoRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.cashInfoRet} cashInfoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashInfoRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a cashInfoRet message.
             * @function verify
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            cashInfoRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.friendNum != null && message.hasOwnProperty("friendNum"))
                    if (!$util.isInteger(message.friendNum))
                        return "friendNum: integer expected";
                if (message.cashInfoList != null && message.hasOwnProperty("cashInfoList")) {
                    if (!Array.isArray(message.cashInfoList))
                        return "cashInfoList: array expected";
                    for (var i = 0; i < message.cashInfoList.length; ++i) {
                        var error = $root.msg.info.cashInfo.verify(message.cashInfoList[i]);
                        if (error)
                            return "cashInfoList." + error;
                    }
                }
                return null;
            };

            /**
             * Creates a cashInfoRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.cashInfoRet} cashInfoRet
             */
            cashInfoRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.cashInfoRet)
                    return object;
                var message = new $root.msg.info.cashInfoRet();
                if (object.friendNum != null)
                    message.friendNum = object.friendNum | 0;
                if (object.cashInfoList) {
                    if (!Array.isArray(object.cashInfoList))
                        throw TypeError(".msg.info.cashInfoRet.cashInfoList: array expected");
                    message.cashInfoList = [];
                    for (var i = 0; i < object.cashInfoList.length; ++i) {
                        if (typeof object.cashInfoList[i] !== "object")
                            throw TypeError(".msg.info.cashInfoRet.cashInfoList: object expected");
                        message.cashInfoList[i] = $root.msg.info.cashInfo.fromObject(object.cashInfoList[i]);
                    }
                }
                return message;
            };

            /**
             * Creates a plain object from a cashInfoRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.cashInfoRet
             * @static
             * @param {msg.info.cashInfoRet} message cashInfoRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            cashInfoRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.arrays || options.defaults)
                    object.cashInfoList = [];
                if (options.defaults)
                    object.friendNum = 0;
                if (message.friendNum != null && message.hasOwnProperty("friendNum"))
                    object.friendNum = message.friendNum;
                if (message.cashInfoList && message.cashInfoList.length) {
                    object.cashInfoList = [];
                    for (var j = 0; j < message.cashInfoList.length; ++j)
                        object.cashInfoList[j] = $root.msg.info.cashInfo.toObject(message.cashInfoList[j], options);
                }
                return object;
            };

            /**
             * Converts this cashInfoRet to JSON.
             * @function toJSON
             * @memberof msg.info.cashInfoRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            cashInfoRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return cashInfoRet;
        })();

        info.popHongbaoRet = (function() {

            /**
             * Properties of a popHongbaoRet.
             * @memberof msg.info
             * @interface IpopHongbaoRet
             * @property {number|null} [type] popHongbaoRet type
             * @property {number|null} [hongbao] popHongbaoRet hongbao
             */

            /**
             * Constructs a new popHongbaoRet.
             * @memberof msg.info
             * @classdesc Represents a popHongbaoRet.
             * @implements IpopHongbaoRet
             * @constructor
             * @param {msg.info.IpopHongbaoRet=} [properties] Properties to set
             */
            function popHongbaoRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * popHongbaoRet type.
             * @member {number} type
             * @memberof msg.info.popHongbaoRet
             * @instance
             */
            popHongbaoRet.prototype.type = 0;

            /**
             * popHongbaoRet hongbao.
             * @member {number} hongbao
             * @memberof msg.info.popHongbaoRet
             * @instance
             */
            popHongbaoRet.prototype.hongbao = 0;

            /**
             * Creates a new popHongbaoRet instance using the specified properties.
             * @function create
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {msg.info.IpopHongbaoRet=} [properties] Properties to set
             * @returns {msg.info.popHongbaoRet} popHongbaoRet instance
             */
            popHongbaoRet.create = function create(properties) {
                return new popHongbaoRet(properties);
            };

            /**
             * Encodes the specified popHongbaoRet message. Does not implicitly {@link msg.info.popHongbaoRet.verify|verify} messages.
             * @function encode
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {msg.info.IpopHongbaoRet} message popHongbaoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            popHongbaoRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.hongbao != null && Object.hasOwnProperty.call(message, "hongbao"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.hongbao);
                return writer;
            };

            /**
             * Encodes the specified popHongbaoRet message, length delimited. Does not implicitly {@link msg.info.popHongbaoRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {msg.info.IpopHongbaoRet} message popHongbaoRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            popHongbaoRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a popHongbaoRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.info.popHongbaoRet} popHongbaoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            popHongbaoRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.info.popHongbaoRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.hongbao = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a popHongbaoRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.info.popHongbaoRet} popHongbaoRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            popHongbaoRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a popHongbaoRet message.
             * @function verify
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            popHongbaoRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    if (!$util.isInteger(message.hongbao))
                        return "hongbao: integer expected";
                return null;
            };

            /**
             * Creates a popHongbaoRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.info.popHongbaoRet} popHongbaoRet
             */
            popHongbaoRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.info.popHongbaoRet)
                    return object;
                var message = new $root.msg.info.popHongbaoRet();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.hongbao != null)
                    message.hongbao = object.hongbao | 0;
                return message;
            };

            /**
             * Creates a plain object from a popHongbaoRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.info.popHongbaoRet
             * @static
             * @param {msg.info.popHongbaoRet} message popHongbaoRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            popHongbaoRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.hongbao = 0;
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    object.hongbao = message.hongbao;
                return object;
            };

            /**
             * Converts this popHongbaoRet to JSON.
             * @function toJSON
             * @memberof msg.info.popHongbaoRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            popHongbaoRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return popHongbaoRet;
        })();

        return info;
    })();

    msg.notice = (function() {

        /**
         * Namespace notice.
         * @memberof msg
         * @namespace
         */
        var notice = {};

        notice.adRecordReq = (function() {

            /**
             * Properties of an adRecordReq.
             * @memberof msg.notice
             * @interface IadRecordReq
             * @property {string|null} [adId] adRecordReq adId
             * @property {string|null} [adKind] adRecordReq adKind
             * @property {string|null} [type] adRecordReq type
             * @property {number|null} [state] adRecordReq state
             */

            /**
             * Constructs a new adRecordReq.
             * @memberof msg.notice
             * @classdesc Represents an adRecordReq.
             * @implements IadRecordReq
             * @constructor
             * @param {msg.notice.IadRecordReq=} [properties] Properties to set
             */
            function adRecordReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * adRecordReq adId.
             * @member {string} adId
             * @memberof msg.notice.adRecordReq
             * @instance
             */
            adRecordReq.prototype.adId = "";

            /**
             * adRecordReq adKind.
             * @member {string} adKind
             * @memberof msg.notice.adRecordReq
             * @instance
             */
            adRecordReq.prototype.adKind = "";

            /**
             * adRecordReq type.
             * @member {string} type
             * @memberof msg.notice.adRecordReq
             * @instance
             */
            adRecordReq.prototype.type = "";

            /**
             * adRecordReq state.
             * @member {number} state
             * @memberof msg.notice.adRecordReq
             * @instance
             */
            adRecordReq.prototype.state = 0;

            /**
             * Creates a new adRecordReq instance using the specified properties.
             * @function create
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {msg.notice.IadRecordReq=} [properties] Properties to set
             * @returns {msg.notice.adRecordReq} adRecordReq instance
             */
            adRecordReq.create = function create(properties) {
                return new adRecordReq(properties);
            };

            /**
             * Encodes the specified adRecordReq message. Does not implicitly {@link msg.notice.adRecordReq.verify|verify} messages.
             * @function encode
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {msg.notice.IadRecordReq} message adRecordReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adRecordReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.adId != null && Object.hasOwnProperty.call(message, "adId"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.adId);
                if (message.adKind != null && Object.hasOwnProperty.call(message, "adKind"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.adKind);
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.type);
                if (message.state != null && Object.hasOwnProperty.call(message, "state"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.state);
                return writer;
            };

            /**
             * Encodes the specified adRecordReq message, length delimited. Does not implicitly {@link msg.notice.adRecordReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {msg.notice.IadRecordReq} message adRecordReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adRecordReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes an adRecordReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.notice.adRecordReq} adRecordReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adRecordReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.notice.adRecordReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.adId = reader.string();
                        break;
                    case 2:
                        message.adKind = reader.string();
                        break;
                    case 3:
                        message.type = reader.string();
                        break;
                    case 4:
                        message.state = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes an adRecordReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.notice.adRecordReq} adRecordReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adRecordReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies an adRecordReq message.
             * @function verify
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            adRecordReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.adId != null && message.hasOwnProperty("adId"))
                    if (!$util.isString(message.adId))
                        return "adId: string expected";
                if (message.adKind != null && message.hasOwnProperty("adKind"))
                    if (!$util.isString(message.adKind))
                        return "adKind: string expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isString(message.type))
                        return "type: string expected";
                if (message.state != null && message.hasOwnProperty("state"))
                    if (!$util.isInteger(message.state))
                        return "state: integer expected";
                return null;
            };

            /**
             * Creates an adRecordReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.notice.adRecordReq} adRecordReq
             */
            adRecordReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.notice.adRecordReq)
                    return object;
                var message = new $root.msg.notice.adRecordReq();
                if (object.adId != null)
                    message.adId = String(object.adId);
                if (object.adKind != null)
                    message.adKind = String(object.adKind);
                if (object.type != null)
                    message.type = String(object.type);
                if (object.state != null)
                    message.state = object.state | 0;
                return message;
            };

            /**
             * Creates a plain object from an adRecordReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.notice.adRecordReq
             * @static
             * @param {msg.notice.adRecordReq} message adRecordReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            adRecordReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.adId = "";
                    object.adKind = "";
                    object.type = "";
                    object.state = 0;
                }
                if (message.adId != null && message.hasOwnProperty("adId"))
                    object.adId = message.adId;
                if (message.adKind != null && message.hasOwnProperty("adKind"))
                    object.adKind = message.adKind;
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.state != null && message.hasOwnProperty("state"))
                    object.state = message.state;
                return object;
            };

            /**
             * Converts this adRecordReq to JSON.
             * @function toJSON
             * @memberof msg.notice.adRecordReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            adRecordReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return adRecordReq;
        })();

        notice.adShowReq = (function() {

            /**
             * Properties of an adShowReq.
             * @memberof msg.notice
             * @interface IadShowReq
             * @property {string|null} [adType] adShowReq adType
             * @property {string|null} [parameter] adShowReq parameter
             */

            /**
             * Constructs a new adShowReq.
             * @memberof msg.notice
             * @classdesc Represents an adShowReq.
             * @implements IadShowReq
             * @constructor
             * @param {msg.notice.IadShowReq=} [properties] Properties to set
             */
            function adShowReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * adShowReq adType.
             * @member {string} adType
             * @memberof msg.notice.adShowReq
             * @instance
             */
            adShowReq.prototype.adType = "";

            /**
             * adShowReq parameter.
             * @member {string} parameter
             * @memberof msg.notice.adShowReq
             * @instance
             */
            adShowReq.prototype.parameter = "";

            /**
             * Creates a new adShowReq instance using the specified properties.
             * @function create
             * @memberof msg.notice.adShowReq
             * @static
             * @param {msg.notice.IadShowReq=} [properties] Properties to set
             * @returns {msg.notice.adShowReq} adShowReq instance
             */
            adShowReq.create = function create(properties) {
                return new adShowReq(properties);
            };

            /**
             * Encodes the specified adShowReq message. Does not implicitly {@link msg.notice.adShowReq.verify|verify} messages.
             * @function encode
             * @memberof msg.notice.adShowReq
             * @static
             * @param {msg.notice.IadShowReq} message adShowReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adShowReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.adType != null && Object.hasOwnProperty.call(message, "adType"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.adType);
                if (message.parameter != null && Object.hasOwnProperty.call(message, "parameter"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.parameter);
                return writer;
            };

            /**
             * Encodes the specified adShowReq message, length delimited. Does not implicitly {@link msg.notice.adShowReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.notice.adShowReq
             * @static
             * @param {msg.notice.IadShowReq} message adShowReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adShowReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes an adShowReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.notice.adShowReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.notice.adShowReq} adShowReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adShowReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.notice.adShowReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.adType = reader.string();
                        break;
                    case 2:
                        message.parameter = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes an adShowReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.notice.adShowReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.notice.adShowReq} adShowReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adShowReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies an adShowReq message.
             * @function verify
             * @memberof msg.notice.adShowReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            adShowReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.adType != null && message.hasOwnProperty("adType"))
                    if (!$util.isString(message.adType))
                        return "adType: string expected";
                if (message.parameter != null && message.hasOwnProperty("parameter"))
                    if (!$util.isString(message.parameter))
                        return "parameter: string expected";
                return null;
            };

            /**
             * Creates an adShowReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.notice.adShowReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.notice.adShowReq} adShowReq
             */
            adShowReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.notice.adShowReq)
                    return object;
                var message = new $root.msg.notice.adShowReq();
                if (object.adType != null)
                    message.adType = String(object.adType);
                if (object.parameter != null)
                    message.parameter = String(object.parameter);
                return message;
            };

            /**
             * Creates a plain object from an adShowReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.notice.adShowReq
             * @static
             * @param {msg.notice.adShowReq} message adShowReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            adShowReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.adType = "";
                    object.parameter = "";
                }
                if (message.adType != null && message.hasOwnProperty("adType"))
                    object.adType = message.adType;
                if (message.parameter != null && message.hasOwnProperty("parameter"))
                    object.parameter = message.parameter;
                return object;
            };

            /**
             * Converts this adShowReq to JSON.
             * @function toJSON
             * @memberof msg.notice.adShowReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            adShowReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return adShowReq;
        })();

        notice.adShowRet = (function() {

            /**
             * Properties of an adShowRet.
             * @memberof msg.notice
             * @interface IadShowRet
             * @property {string|null} [adType] adShowRet adType
             * @property {number|null} [showFullScreen] adShowRet showFullScreen
             * @property {number|null} [showInsertScreen] adShowRet showInsertScreen
             */

            /**
             * Constructs a new adShowRet.
             * @memberof msg.notice
             * @classdesc Represents an adShowRet.
             * @implements IadShowRet
             * @constructor
             * @param {msg.notice.IadShowRet=} [properties] Properties to set
             */
            function adShowRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * adShowRet adType.
             * @member {string} adType
             * @memberof msg.notice.adShowRet
             * @instance
             */
            adShowRet.prototype.adType = "";

            /**
             * adShowRet showFullScreen.
             * @member {number} showFullScreen
             * @memberof msg.notice.adShowRet
             * @instance
             */
            adShowRet.prototype.showFullScreen = 0;

            /**
             * adShowRet showInsertScreen.
             * @member {number} showInsertScreen
             * @memberof msg.notice.adShowRet
             * @instance
             */
            adShowRet.prototype.showInsertScreen = 0;

            /**
             * Creates a new adShowRet instance using the specified properties.
             * @function create
             * @memberof msg.notice.adShowRet
             * @static
             * @param {msg.notice.IadShowRet=} [properties] Properties to set
             * @returns {msg.notice.adShowRet} adShowRet instance
             */
            adShowRet.create = function create(properties) {
                return new adShowRet(properties);
            };

            /**
             * Encodes the specified adShowRet message. Does not implicitly {@link msg.notice.adShowRet.verify|verify} messages.
             * @function encode
             * @memberof msg.notice.adShowRet
             * @static
             * @param {msg.notice.IadShowRet} message adShowRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adShowRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.adType != null && Object.hasOwnProperty.call(message, "adType"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.adType);
                if (message.showFullScreen != null && Object.hasOwnProperty.call(message, "showFullScreen"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.showFullScreen);
                if (message.showInsertScreen != null && Object.hasOwnProperty.call(message, "showInsertScreen"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.showInsertScreen);
                return writer;
            };

            /**
             * Encodes the specified adShowRet message, length delimited. Does not implicitly {@link msg.notice.adShowRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.notice.adShowRet
             * @static
             * @param {msg.notice.IadShowRet} message adShowRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            adShowRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes an adShowRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.notice.adShowRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.notice.adShowRet} adShowRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adShowRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.notice.adShowRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.adType = reader.string();
                        break;
                    case 2:
                        message.showFullScreen = reader.int32();
                        break;
                    case 3:
                        message.showInsertScreen = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes an adShowRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.notice.adShowRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.notice.adShowRet} adShowRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            adShowRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies an adShowRet message.
             * @function verify
             * @memberof msg.notice.adShowRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            adShowRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.adType != null && message.hasOwnProperty("adType"))
                    if (!$util.isString(message.adType))
                        return "adType: string expected";
                if (message.showFullScreen != null && message.hasOwnProperty("showFullScreen"))
                    if (!$util.isInteger(message.showFullScreen))
                        return "showFullScreen: integer expected";
                if (message.showInsertScreen != null && message.hasOwnProperty("showInsertScreen"))
                    if (!$util.isInteger(message.showInsertScreen))
                        return "showInsertScreen: integer expected";
                return null;
            };

            /**
             * Creates an adShowRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.notice.adShowRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.notice.adShowRet} adShowRet
             */
            adShowRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.notice.adShowRet)
                    return object;
                var message = new $root.msg.notice.adShowRet();
                if (object.adType != null)
                    message.adType = String(object.adType);
                if (object.showFullScreen != null)
                    message.showFullScreen = object.showFullScreen | 0;
                if (object.showInsertScreen != null)
                    message.showInsertScreen = object.showInsertScreen | 0;
                return message;
            };

            /**
             * Creates a plain object from an adShowRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.notice.adShowRet
             * @static
             * @param {msg.notice.adShowRet} message adShowRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            adShowRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.adType = "";
                    object.showFullScreen = 0;
                    object.showInsertScreen = 0;
                }
                if (message.adType != null && message.hasOwnProperty("adType"))
                    object.adType = message.adType;
                if (message.showFullScreen != null && message.hasOwnProperty("showFullScreen"))
                    object.showFullScreen = message.showFullScreen;
                if (message.showInsertScreen != null && message.hasOwnProperty("showInsertScreen"))
                    object.showInsertScreen = message.showInsertScreen;
                return object;
            };

            /**
             * Converts this adShowRet to JSON.
             * @function toJSON
             * @memberof msg.notice.adShowRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            adShowRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return adShowRet;
        })();

        notice.noticeRet = (function() {

            /**
             * Properties of a noticeRet.
             * @memberof msg.notice
             * @interface InoticeRet
             * @property {number|null} [type] noticeRet type
             * @property {string|null} [protocolId] noticeRet protocolId
             * @property {string|null} [errormsg] noticeRet errormsg
             */

            /**
             * Constructs a new noticeRet.
             * @memberof msg.notice
             * @classdesc Represents a noticeRet.
             * @implements InoticeRet
             * @constructor
             * @param {msg.notice.InoticeRet=} [properties] Properties to set
             */
            function noticeRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * noticeRet type.
             * @member {number} type
             * @memberof msg.notice.noticeRet
             * @instance
             */
            noticeRet.prototype.type = 0;

            /**
             * noticeRet protocolId.
             * @member {string} protocolId
             * @memberof msg.notice.noticeRet
             * @instance
             */
            noticeRet.prototype.protocolId = "";

            /**
             * noticeRet errormsg.
             * @member {string} errormsg
             * @memberof msg.notice.noticeRet
             * @instance
             */
            noticeRet.prototype.errormsg = "";

            /**
             * Creates a new noticeRet instance using the specified properties.
             * @function create
             * @memberof msg.notice.noticeRet
             * @static
             * @param {msg.notice.InoticeRet=} [properties] Properties to set
             * @returns {msg.notice.noticeRet} noticeRet instance
             */
            noticeRet.create = function create(properties) {
                return new noticeRet(properties);
            };

            /**
             * Encodes the specified noticeRet message. Does not implicitly {@link msg.notice.noticeRet.verify|verify} messages.
             * @function encode
             * @memberof msg.notice.noticeRet
             * @static
             * @param {msg.notice.InoticeRet} message noticeRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            noticeRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.protocolId != null && Object.hasOwnProperty.call(message, "protocolId"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.protocolId);
                if (message.errormsg != null && Object.hasOwnProperty.call(message, "errormsg"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.errormsg);
                return writer;
            };

            /**
             * Encodes the specified noticeRet message, length delimited. Does not implicitly {@link msg.notice.noticeRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.notice.noticeRet
             * @static
             * @param {msg.notice.InoticeRet} message noticeRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            noticeRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a noticeRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.notice.noticeRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.notice.noticeRet} noticeRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            noticeRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.notice.noticeRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.protocolId = reader.string();
                        break;
                    case 3:
                        message.errormsg = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a noticeRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.notice.noticeRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.notice.noticeRet} noticeRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            noticeRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a noticeRet message.
             * @function verify
             * @memberof msg.notice.noticeRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            noticeRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.protocolId != null && message.hasOwnProperty("protocolId"))
                    if (!$util.isString(message.protocolId))
                        return "protocolId: string expected";
                if (message.errormsg != null && message.hasOwnProperty("errormsg"))
                    if (!$util.isString(message.errormsg))
                        return "errormsg: string expected";
                return null;
            };

            /**
             * Creates a noticeRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.notice.noticeRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.notice.noticeRet} noticeRet
             */
            noticeRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.notice.noticeRet)
                    return object;
                var message = new $root.msg.notice.noticeRet();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.protocolId != null)
                    message.protocolId = String(object.protocolId);
                if (object.errormsg != null)
                    message.errormsg = String(object.errormsg);
                return message;
            };

            /**
             * Creates a plain object from a noticeRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.notice.noticeRet
             * @static
             * @param {msg.notice.noticeRet} message noticeRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            noticeRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.protocolId = "";
                    object.errormsg = "";
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.protocolId != null && message.hasOwnProperty("protocolId"))
                    object.protocolId = message.protocolId;
                if (message.errormsg != null && message.hasOwnProperty("errormsg"))
                    object.errormsg = message.errormsg;
                return object;
            };

            /**
             * Converts this noticeRet to JSON.
             * @function toJSON
             * @memberof msg.notice.noticeRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            noticeRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return noticeRet;
        })();

        return notice;
    })();

    msg.action = (function() {

        /**
         * Namespace action.
         * @memberof msg
         * @namespace
         */
        var action = {};

        action.rewardReq = (function() {

            /**
             * Properties of a rewardReq.
             * @memberof msg.action
             * @interface IrewardReq
             * @property {number|null} [type] rewardReq type
             * @property {number|null} [isSeeAd] rewardReq isSeeAd
             * @property {number|null} [index] rewardReq index
             */

            /**
             * Constructs a new rewardReq.
             * @memberof msg.action
             * @classdesc Represents a rewardReq.
             * @implements IrewardReq
             * @constructor
             * @param {msg.action.IrewardReq=} [properties] Properties to set
             */
            function rewardReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * rewardReq type.
             * @member {number} type
             * @memberof msg.action.rewardReq
             * @instance
             */
            rewardReq.prototype.type = 0;

            /**
             * rewardReq isSeeAd.
             * @member {number} isSeeAd
             * @memberof msg.action.rewardReq
             * @instance
             */
            rewardReq.prototype.isSeeAd = 0;

            /**
             * rewardReq index.
             * @member {number} index
             * @memberof msg.action.rewardReq
             * @instance
             */
            rewardReq.prototype.index = 0;

            /**
             * Creates a new rewardReq instance using the specified properties.
             * @function create
             * @memberof msg.action.rewardReq
             * @static
             * @param {msg.action.IrewardReq=} [properties] Properties to set
             * @returns {msg.action.rewardReq} rewardReq instance
             */
            rewardReq.create = function create(properties) {
                return new rewardReq(properties);
            };

            /**
             * Encodes the specified rewardReq message. Does not implicitly {@link msg.action.rewardReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.rewardReq
             * @static
             * @param {msg.action.IrewardReq} message rewardReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            rewardReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.isSeeAd != null && Object.hasOwnProperty.call(message, "isSeeAd"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.isSeeAd);
                if (message.index != null && Object.hasOwnProperty.call(message, "index"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.index);
                return writer;
            };

            /**
             * Encodes the specified rewardReq message, length delimited. Does not implicitly {@link msg.action.rewardReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.rewardReq
             * @static
             * @param {msg.action.IrewardReq} message rewardReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            rewardReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a rewardReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.rewardReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.rewardReq} rewardReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            rewardReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.rewardReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.isSeeAd = reader.int32();
                        break;
                    case 3:
                        message.index = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a rewardReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.rewardReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.rewardReq} rewardReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            rewardReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a rewardReq message.
             * @function verify
             * @memberof msg.action.rewardReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            rewardReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.isSeeAd != null && message.hasOwnProperty("isSeeAd"))
                    if (!$util.isInteger(message.isSeeAd))
                        return "isSeeAd: integer expected";
                if (message.index != null && message.hasOwnProperty("index"))
                    if (!$util.isInteger(message.index))
                        return "index: integer expected";
                return null;
            };

            /**
             * Creates a rewardReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.rewardReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.rewardReq} rewardReq
             */
            rewardReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.rewardReq)
                    return object;
                var message = new $root.msg.action.rewardReq();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.isSeeAd != null)
                    message.isSeeAd = object.isSeeAd | 0;
                if (object.index != null)
                    message.index = object.index | 0;
                return message;
            };

            /**
             * Creates a plain object from a rewardReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.rewardReq
             * @static
             * @param {msg.action.rewardReq} message rewardReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            rewardReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.isSeeAd = 0;
                    object.index = 0;
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.isSeeAd != null && message.hasOwnProperty("isSeeAd"))
                    object.isSeeAd = message.isSeeAd;
                if (message.index != null && message.hasOwnProperty("index"))
                    object.index = message.index;
                return object;
            };

            /**
             * Converts this rewardReq to JSON.
             * @function toJSON
             * @memberof msg.action.rewardReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            rewardReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return rewardReq;
        })();

        action.rewardRet = (function() {

            /**
             * Properties of a rewardRet.
             * @memberof msg.action
             * @interface IrewardRet
             * @property {number|null} [type] rewardRet type
             * @property {string|null} [ret] rewardRet ret
             * @property {string|null} [ret_2] rewardRet ret_2
             */

            /**
             * Constructs a new rewardRet.
             * @memberof msg.action
             * @classdesc Represents a rewardRet.
             * @implements IrewardRet
             * @constructor
             * @param {msg.action.IrewardRet=} [properties] Properties to set
             */
            function rewardRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * rewardRet type.
             * @member {number} type
             * @memberof msg.action.rewardRet
             * @instance
             */
            rewardRet.prototype.type = 0;

            /**
             * rewardRet ret.
             * @member {string} ret
             * @memberof msg.action.rewardRet
             * @instance
             */
            rewardRet.prototype.ret = "";

            /**
             * rewardRet ret_2.
             * @member {string} ret_2
             * @memberof msg.action.rewardRet
             * @instance
             */
            rewardRet.prototype.ret_2 = "";

            /**
             * Creates a new rewardRet instance using the specified properties.
             * @function create
             * @memberof msg.action.rewardRet
             * @static
             * @param {msg.action.IrewardRet=} [properties] Properties to set
             * @returns {msg.action.rewardRet} rewardRet instance
             */
            rewardRet.create = function create(properties) {
                return new rewardRet(properties);
            };

            /**
             * Encodes the specified rewardRet message. Does not implicitly {@link msg.action.rewardRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.rewardRet
             * @static
             * @param {msg.action.IrewardRet} message rewardRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            rewardRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.ret != null && Object.hasOwnProperty.call(message, "ret"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.ret);
                if (message.ret_2 != null && Object.hasOwnProperty.call(message, "ret_2"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.ret_2);
                return writer;
            };

            /**
             * Encodes the specified rewardRet message, length delimited. Does not implicitly {@link msg.action.rewardRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.rewardRet
             * @static
             * @param {msg.action.IrewardRet} message rewardRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            rewardRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a rewardRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.rewardRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.rewardRet} rewardRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            rewardRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.rewardRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.ret = reader.string();
                        break;
                    case 3:
                        message.ret_2 = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a rewardRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.rewardRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.rewardRet} rewardRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            rewardRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a rewardRet message.
             * @function verify
             * @memberof msg.action.rewardRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            rewardRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.ret != null && message.hasOwnProperty("ret"))
                    if (!$util.isString(message.ret))
                        return "ret: string expected";
                if (message.ret_2 != null && message.hasOwnProperty("ret_2"))
                    if (!$util.isString(message.ret_2))
                        return "ret_2: string expected";
                return null;
            };

            /**
             * Creates a rewardRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.rewardRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.rewardRet} rewardRet
             */
            rewardRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.rewardRet)
                    return object;
                var message = new $root.msg.action.rewardRet();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.ret != null)
                    message.ret = String(object.ret);
                if (object.ret_2 != null)
                    message.ret_2 = String(object.ret_2);
                return message;
            };

            /**
             * Creates a plain object from a rewardRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.rewardRet
             * @static
             * @param {msg.action.rewardRet} message rewardRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            rewardRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.ret = "";
                    object.ret_2 = "";
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.ret != null && message.hasOwnProperty("ret"))
                    object.ret = message.ret;
                if (message.ret_2 != null && message.hasOwnProperty("ret_2"))
                    object.ret_2 = message.ret_2;
                return object;
            };

            /**
             * Converts this rewardRet to JSON.
             * @function toJSON
             * @memberof msg.action.rewardRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            rewardRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return rewardRet;
        })();

        action.playerSetReq = (function() {

            /**
             * Properties of a playerSetReq.
             * @memberof msg.action
             * @interface IplayerSetReq
             * @property {number|null} [whiteSwitch] playerSetReq whiteSwitch
             */

            /**
             * Constructs a new playerSetReq.
             * @memberof msg.action
             * @classdesc Represents a playerSetReq.
             * @implements IplayerSetReq
             * @constructor
             * @param {msg.action.IplayerSetReq=} [properties] Properties to set
             */
            function playerSetReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * playerSetReq whiteSwitch.
             * @member {number} whiteSwitch
             * @memberof msg.action.playerSetReq
             * @instance
             */
            playerSetReq.prototype.whiteSwitch = 0;

            /**
             * Creates a new playerSetReq instance using the specified properties.
             * @function create
             * @memberof msg.action.playerSetReq
             * @static
             * @param {msg.action.IplayerSetReq=} [properties] Properties to set
             * @returns {msg.action.playerSetReq} playerSetReq instance
             */
            playerSetReq.create = function create(properties) {
                return new playerSetReq(properties);
            };

            /**
             * Encodes the specified playerSetReq message. Does not implicitly {@link msg.action.playerSetReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.playerSetReq
             * @static
             * @param {msg.action.IplayerSetReq} message playerSetReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerSetReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.whiteSwitch != null && Object.hasOwnProperty.call(message, "whiteSwitch"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.whiteSwitch);
                return writer;
            };

            /**
             * Encodes the specified playerSetReq message, length delimited. Does not implicitly {@link msg.action.playerSetReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.playerSetReq
             * @static
             * @param {msg.action.IplayerSetReq} message playerSetReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            playerSetReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a playerSetReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.playerSetReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.playerSetReq} playerSetReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerSetReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.playerSetReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.whiteSwitch = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a playerSetReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.playerSetReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.playerSetReq} playerSetReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            playerSetReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a playerSetReq message.
             * @function verify
             * @memberof msg.action.playerSetReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            playerSetReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.whiteSwitch != null && message.hasOwnProperty("whiteSwitch"))
                    if (!$util.isInteger(message.whiteSwitch))
                        return "whiteSwitch: integer expected";
                return null;
            };

            /**
             * Creates a playerSetReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.playerSetReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.playerSetReq} playerSetReq
             */
            playerSetReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.playerSetReq)
                    return object;
                var message = new $root.msg.action.playerSetReq();
                if (object.whiteSwitch != null)
                    message.whiteSwitch = object.whiteSwitch | 0;
                return message;
            };

            /**
             * Creates a plain object from a playerSetReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.playerSetReq
             * @static
             * @param {msg.action.playerSetReq} message playerSetReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            playerSetReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults)
                    object.whiteSwitch = 0;
                if (message.whiteSwitch != null && message.hasOwnProperty("whiteSwitch"))
                    object.whiteSwitch = message.whiteSwitch;
                return object;
            };

            /**
             * Converts this playerSetReq to JSON.
             * @function toJSON
             * @memberof msg.action.playerSetReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            playerSetReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return playerSetReq;
        })();

        action.clientLogReq = (function() {

            /**
             * Properties of a clientLogReq.
             * @memberof msg.action
             * @interface IclientLogReq
             * @property {string|null} [version] clientLogReq version
             * @property {string|null} [system] clientLogReq system
             * @property {string|null} [log] clientLogReq log
             * @property {string|null} [logLevel] clientLogReq logLevel
             */

            /**
             * Constructs a new clientLogReq.
             * @memberof msg.action
             * @classdesc Represents a clientLogReq.
             * @implements IclientLogReq
             * @constructor
             * @param {msg.action.IclientLogReq=} [properties] Properties to set
             */
            function clientLogReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * clientLogReq version.
             * @member {string} version
             * @memberof msg.action.clientLogReq
             * @instance
             */
            clientLogReq.prototype.version = "";

            /**
             * clientLogReq system.
             * @member {string} system
             * @memberof msg.action.clientLogReq
             * @instance
             */
            clientLogReq.prototype.system = "";

            /**
             * clientLogReq log.
             * @member {string} log
             * @memberof msg.action.clientLogReq
             * @instance
             */
            clientLogReq.prototype.log = "";

            /**
             * clientLogReq logLevel.
             * @member {string} logLevel
             * @memberof msg.action.clientLogReq
             * @instance
             */
            clientLogReq.prototype.logLevel = "";

            /**
             * Creates a new clientLogReq instance using the specified properties.
             * @function create
             * @memberof msg.action.clientLogReq
             * @static
             * @param {msg.action.IclientLogReq=} [properties] Properties to set
             * @returns {msg.action.clientLogReq} clientLogReq instance
             */
            clientLogReq.create = function create(properties) {
                return new clientLogReq(properties);
            };

            /**
             * Encodes the specified clientLogReq message. Does not implicitly {@link msg.action.clientLogReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.clientLogReq
             * @static
             * @param {msg.action.IclientLogReq} message clientLogReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            clientLogReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.version != null && Object.hasOwnProperty.call(message, "version"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.version);
                if (message.system != null && Object.hasOwnProperty.call(message, "system"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.system);
                if (message.log != null && Object.hasOwnProperty.call(message, "log"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.log);
                if (message.logLevel != null && Object.hasOwnProperty.call(message, "logLevel"))
                    writer.uint32(/* id 4, wireType 2 =*/34).string(message.logLevel);
                return writer;
            };

            /**
             * Encodes the specified clientLogReq message, length delimited. Does not implicitly {@link msg.action.clientLogReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.clientLogReq
             * @static
             * @param {msg.action.IclientLogReq} message clientLogReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            clientLogReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a clientLogReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.clientLogReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.clientLogReq} clientLogReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            clientLogReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.clientLogReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.version = reader.string();
                        break;
                    case 2:
                        message.system = reader.string();
                        break;
                    case 3:
                        message.log = reader.string();
                        break;
                    case 4:
                        message.logLevel = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a clientLogReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.clientLogReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.clientLogReq} clientLogReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            clientLogReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a clientLogReq message.
             * @function verify
             * @memberof msg.action.clientLogReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            clientLogReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.version != null && message.hasOwnProperty("version"))
                    if (!$util.isString(message.version))
                        return "version: string expected";
                if (message.system != null && message.hasOwnProperty("system"))
                    if (!$util.isString(message.system))
                        return "system: string expected";
                if (message.log != null && message.hasOwnProperty("log"))
                    if (!$util.isString(message.log))
                        return "log: string expected";
                if (message.logLevel != null && message.hasOwnProperty("logLevel"))
                    if (!$util.isString(message.logLevel))
                        return "logLevel: string expected";
                return null;
            };

            /**
             * Creates a clientLogReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.clientLogReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.clientLogReq} clientLogReq
             */
            clientLogReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.clientLogReq)
                    return object;
                var message = new $root.msg.action.clientLogReq();
                if (object.version != null)
                    message.version = String(object.version);
                if (object.system != null)
                    message.system = String(object.system);
                if (object.log != null)
                    message.log = String(object.log);
                if (object.logLevel != null)
                    message.logLevel = String(object.logLevel);
                return message;
            };

            /**
             * Creates a plain object from a clientLogReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.clientLogReq
             * @static
             * @param {msg.action.clientLogReq} message clientLogReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            clientLogReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.version = "";
                    object.system = "";
                    object.log = "";
                    object.logLevel = "";
                }
                if (message.version != null && message.hasOwnProperty("version"))
                    object.version = message.version;
                if (message.system != null && message.hasOwnProperty("system"))
                    object.system = message.system;
                if (message.log != null && message.hasOwnProperty("log"))
                    object.log = message.log;
                if (message.logLevel != null && message.hasOwnProperty("logLevel"))
                    object.logLevel = message.logLevel;
                return object;
            };

            /**
             * Converts this clientLogReq to JSON.
             * @function toJSON
             * @memberof msg.action.clientLogReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            clientLogReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return clientLogReq;
        })();

        action.activePetMagicReq = (function() {

            /**
             * Properties of an activePetMagicReq.
             * @memberof msg.action
             * @interface IactivePetMagicReq
             * @property {number|null} [type] activePetMagicReq type
             * @property {number|null} [id] activePetMagicReq id
             * @property {string|null} [money] activePetMagicReq money
             */

            /**
             * Constructs a new activePetMagicReq.
             * @memberof msg.action
             * @classdesc Represents an activePetMagicReq.
             * @implements IactivePetMagicReq
             * @constructor
             * @param {msg.action.IactivePetMagicReq=} [properties] Properties to set
             */
            function activePetMagicReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * activePetMagicReq type.
             * @member {number} type
             * @memberof msg.action.activePetMagicReq
             * @instance
             */
            activePetMagicReq.prototype.type = 0;

            /**
             * activePetMagicReq id.
             * @member {number} id
             * @memberof msg.action.activePetMagicReq
             * @instance
             */
            activePetMagicReq.prototype.id = 0;

            /**
             * activePetMagicReq money.
             * @member {string} money
             * @memberof msg.action.activePetMagicReq
             * @instance
             */
            activePetMagicReq.prototype.money = "";

            /**
             * Creates a new activePetMagicReq instance using the specified properties.
             * @function create
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {msg.action.IactivePetMagicReq=} [properties] Properties to set
             * @returns {msg.action.activePetMagicReq} activePetMagicReq instance
             */
            activePetMagicReq.create = function create(properties) {
                return new activePetMagicReq(properties);
            };

            /**
             * Encodes the specified activePetMagicReq message. Does not implicitly {@link msg.action.activePetMagicReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {msg.action.IactivePetMagicReq} message activePetMagicReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            activePetMagicReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.id != null && Object.hasOwnProperty.call(message, "id"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.id);
                if (message.money != null && Object.hasOwnProperty.call(message, "money"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.money);
                return writer;
            };

            /**
             * Encodes the specified activePetMagicReq message, length delimited. Does not implicitly {@link msg.action.activePetMagicReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {msg.action.IactivePetMagicReq} message activePetMagicReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            activePetMagicReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes an activePetMagicReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.activePetMagicReq} activePetMagicReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            activePetMagicReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.activePetMagicReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.id = reader.int32();
                        break;
                    case 3:
                        message.money = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes an activePetMagicReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.activePetMagicReq} activePetMagicReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            activePetMagicReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies an activePetMagicReq message.
             * @function verify
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            activePetMagicReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.id != null && message.hasOwnProperty("id"))
                    if (!$util.isInteger(message.id))
                        return "id: integer expected";
                if (message.money != null && message.hasOwnProperty("money"))
                    if (!$util.isString(message.money))
                        return "money: string expected";
                return null;
            };

            /**
             * Creates an activePetMagicReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.activePetMagicReq} activePetMagicReq
             */
            activePetMagicReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.activePetMagicReq)
                    return object;
                var message = new $root.msg.action.activePetMagicReq();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.id != null)
                    message.id = object.id | 0;
                if (object.money != null)
                    message.money = String(object.money);
                return message;
            };

            /**
             * Creates a plain object from an activePetMagicReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.activePetMagicReq
             * @static
             * @param {msg.action.activePetMagicReq} message activePetMagicReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            activePetMagicReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.id = 0;
                    object.money = "";
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.id != null && message.hasOwnProperty("id"))
                    object.id = message.id;
                if (message.money != null && message.hasOwnProperty("money"))
                    object.money = message.money;
                return object;
            };

            /**
             * Converts this activePetMagicReq to JSON.
             * @function toJSON
             * @memberof msg.action.activePetMagicReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            activePetMagicReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return activePetMagicReq;
        })();

        action.syncMoneyReq = (function() {

            /**
             * Properties of a syncMoneyReq.
             * @memberof msg.action
             * @interface IsyncMoneyReq
             * @property {string|null} [money] syncMoneyReq money
             * @property {number|null} [hongbao] syncMoneyReq hongbao
             * @property {number|null} [marbleNum] syncMoneyReq marbleNum
             * @property {Object.<string,number>|null} [petMap] syncMoneyReq petMap
             * @property {Object.<string,number>|null} [magicMap] syncMoneyReq magicMap
             */

            /**
             * Constructs a new syncMoneyReq.
             * @memberof msg.action
             * @classdesc Represents a syncMoneyReq.
             * @implements IsyncMoneyReq
             * @constructor
             * @param {msg.action.IsyncMoneyReq=} [properties] Properties to set
             */
            function syncMoneyReq(properties) {
                this.petMap = {};
                this.magicMap = {};
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * syncMoneyReq money.
             * @member {string} money
             * @memberof msg.action.syncMoneyReq
             * @instance
             */
            syncMoneyReq.prototype.money = "";

            /**
             * syncMoneyReq hongbao.
             * @member {number} hongbao
             * @memberof msg.action.syncMoneyReq
             * @instance
             */
            syncMoneyReq.prototype.hongbao = 0;

            /**
             * syncMoneyReq marbleNum.
             * @member {number} marbleNum
             * @memberof msg.action.syncMoneyReq
             * @instance
             */
            syncMoneyReq.prototype.marbleNum = 0;

            /**
             * syncMoneyReq petMap.
             * @member {Object.<string,number>} petMap
             * @memberof msg.action.syncMoneyReq
             * @instance
             */
            syncMoneyReq.prototype.petMap = $util.emptyObject;

            /**
             * syncMoneyReq magicMap.
             * @member {Object.<string,number>} magicMap
             * @memberof msg.action.syncMoneyReq
             * @instance
             */
            syncMoneyReq.prototype.magicMap = $util.emptyObject;

            /**
             * Creates a new syncMoneyReq instance using the specified properties.
             * @function create
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {msg.action.IsyncMoneyReq=} [properties] Properties to set
             * @returns {msg.action.syncMoneyReq} syncMoneyReq instance
             */
            syncMoneyReq.create = function create(properties) {
                return new syncMoneyReq(properties);
            };

            /**
             * Encodes the specified syncMoneyReq message. Does not implicitly {@link msg.action.syncMoneyReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {msg.action.IsyncMoneyReq} message syncMoneyReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncMoneyReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.money != null && Object.hasOwnProperty.call(message, "money"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.money);
                if (message.hongbao != null && Object.hasOwnProperty.call(message, "hongbao"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.hongbao);
                if (message.marbleNum != null && Object.hasOwnProperty.call(message, "marbleNum"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.marbleNum);
                if (message.petMap != null && Object.hasOwnProperty.call(message, "petMap"))
                    for (var keys = Object.keys(message.petMap), i = 0; i < keys.length; ++i)
                        writer.uint32(/* id 5, wireType 2 =*/42).fork().uint32(/* id 1, wireType 0 =*/8).int32(keys[i]).uint32(/* id 2, wireType 0 =*/16).int32(message.petMap[keys[i]]).ldelim();
                if (message.magicMap != null && Object.hasOwnProperty.call(message, "magicMap"))
                    for (var keys = Object.keys(message.magicMap), i = 0; i < keys.length; ++i)
                        writer.uint32(/* id 6, wireType 2 =*/50).fork().uint32(/* id 1, wireType 0 =*/8).int32(keys[i]).uint32(/* id 2, wireType 0 =*/16).int32(message.magicMap[keys[i]]).ldelim();
                return writer;
            };

            /**
             * Encodes the specified syncMoneyReq message, length delimited. Does not implicitly {@link msg.action.syncMoneyReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {msg.action.IsyncMoneyReq} message syncMoneyReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncMoneyReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a syncMoneyReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.syncMoneyReq} syncMoneyReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncMoneyReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.syncMoneyReq(), key, value;
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.money = reader.string();
                        break;
                    case 2:
                        message.hongbao = reader.int32();
                        break;
                    case 4:
                        message.marbleNum = reader.int32();
                        break;
                    case 5:
                        if (message.petMap === $util.emptyObject)
                            message.petMap = {};
                        var end2 = reader.uint32() + reader.pos;
                        key = 0;
                        value = 0;
                        while (reader.pos < end2) {
                            var tag2 = reader.uint32();
                            switch (tag2 >>> 3) {
                            case 1:
                                key = reader.int32();
                                break;
                            case 2:
                                value = reader.int32();
                                break;
                            default:
                                reader.skipType(tag2 & 7);
                                break;
                            }
                        }
                        message.petMap[key] = value;
                        break;
                    case 6:
                        if (message.magicMap === $util.emptyObject)
                            message.magicMap = {};
                        var end2 = reader.uint32() + reader.pos;
                        key = 0;
                        value = 0;
                        while (reader.pos < end2) {
                            var tag2 = reader.uint32();
                            switch (tag2 >>> 3) {
                            case 1:
                                key = reader.int32();
                                break;
                            case 2:
                                value = reader.int32();
                                break;
                            default:
                                reader.skipType(tag2 & 7);
                                break;
                            }
                        }
                        message.magicMap[key] = value;
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a syncMoneyReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.syncMoneyReq} syncMoneyReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncMoneyReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a syncMoneyReq message.
             * @function verify
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            syncMoneyReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.money != null && message.hasOwnProperty("money"))
                    if (!$util.isString(message.money))
                        return "money: string expected";
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    if (!$util.isInteger(message.hongbao))
                        return "hongbao: integer expected";
                if (message.marbleNum != null && message.hasOwnProperty("marbleNum"))
                    if (!$util.isInteger(message.marbleNum))
                        return "marbleNum: integer expected";
                if (message.petMap != null && message.hasOwnProperty("petMap")) {
                    if (!$util.isObject(message.petMap))
                        return "petMap: object expected";
                    var key = Object.keys(message.petMap);
                    for (var i = 0; i < key.length; ++i) {
                        if (!$util.key32Re.test(key[i]))
                            return "petMap: integer key{k:int32} expected";
                        if (!$util.isInteger(message.petMap[key[i]]))
                            return "petMap: integer{k:int32} expected";
                    }
                }
                if (message.magicMap != null && message.hasOwnProperty("magicMap")) {
                    if (!$util.isObject(message.magicMap))
                        return "magicMap: object expected";
                    var key = Object.keys(message.magicMap);
                    for (var i = 0; i < key.length; ++i) {
                        if (!$util.key32Re.test(key[i]))
                            return "magicMap: integer key{k:int32} expected";
                        if (!$util.isInteger(message.magicMap[key[i]]))
                            return "magicMap: integer{k:int32} expected";
                    }
                }
                return null;
            };

            /**
             * Creates a syncMoneyReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.syncMoneyReq} syncMoneyReq
             */
            syncMoneyReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.syncMoneyReq)
                    return object;
                var message = new $root.msg.action.syncMoneyReq();
                if (object.money != null)
                    message.money = String(object.money);
                if (object.hongbao != null)
                    message.hongbao = object.hongbao | 0;
                if (object.marbleNum != null)
                    message.marbleNum = object.marbleNum | 0;
                if (object.petMap) {
                    if (typeof object.petMap !== "object")
                        throw TypeError(".msg.action.syncMoneyReq.petMap: object expected");
                    message.petMap = {};
                    for (var keys = Object.keys(object.petMap), i = 0; i < keys.length; ++i)
                        message.petMap[keys[i]] = object.petMap[keys[i]] | 0;
                }
                if (object.magicMap) {
                    if (typeof object.magicMap !== "object")
                        throw TypeError(".msg.action.syncMoneyReq.magicMap: object expected");
                    message.magicMap = {};
                    for (var keys = Object.keys(object.magicMap), i = 0; i < keys.length; ++i)
                        message.magicMap[keys[i]] = object.magicMap[keys[i]] | 0;
                }
                return message;
            };

            /**
             * Creates a plain object from a syncMoneyReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.syncMoneyReq
             * @static
             * @param {msg.action.syncMoneyReq} message syncMoneyReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            syncMoneyReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.objects || options.defaults) {
                    object.petMap = {};
                    object.magicMap = {};
                }
                if (options.defaults) {
                    object.money = "";
                    object.hongbao = 0;
                    object.marbleNum = 0;
                }
                if (message.money != null && message.hasOwnProperty("money"))
                    object.money = message.money;
                if (message.hongbao != null && message.hasOwnProperty("hongbao"))
                    object.hongbao = message.hongbao;
                if (message.marbleNum != null && message.hasOwnProperty("marbleNum"))
                    object.marbleNum = message.marbleNum;
                var keys2;
                if (message.petMap && (keys2 = Object.keys(message.petMap)).length) {
                    object.petMap = {};
                    for (var j = 0; j < keys2.length; ++j)
                        object.petMap[keys2[j]] = message.petMap[keys2[j]];
                }
                if (message.magicMap && (keys2 = Object.keys(message.magicMap)).length) {
                    object.magicMap = {};
                    for (var j = 0; j < keys2.length; ++j)
                        object.magicMap[keys2[j]] = message.magicMap[keys2[j]];
                }
                return object;
            };

            /**
             * Converts this syncMoneyReq to JSON.
             * @function toJSON
             * @memberof msg.action.syncMoneyReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            syncMoneyReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return syncMoneyReq;
        })();

        action.syncMoneyRet = (function() {

            /**
             * Properties of a syncMoneyRet.
             * @memberof msg.action
             * @interface IsyncMoneyRet
             * @property {number|null} [errorCode] syncMoneyRet errorCode
             */

            /**
             * Constructs a new syncMoneyRet.
             * @memberof msg.action
             * @classdesc Represents a syncMoneyRet.
             * @implements IsyncMoneyRet
             * @constructor
             * @param {msg.action.IsyncMoneyRet=} [properties] Properties to set
             */
            function syncMoneyRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * syncMoneyRet errorCode.
             * @member {number} errorCode
             * @memberof msg.action.syncMoneyRet
             * @instance
             */
            syncMoneyRet.prototype.errorCode = 0;

            /**
             * Creates a new syncMoneyRet instance using the specified properties.
             * @function create
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {msg.action.IsyncMoneyRet=} [properties] Properties to set
             * @returns {msg.action.syncMoneyRet} syncMoneyRet instance
             */
            syncMoneyRet.create = function create(properties) {
                return new syncMoneyRet(properties);
            };

            /**
             * Encodes the specified syncMoneyRet message. Does not implicitly {@link msg.action.syncMoneyRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {msg.action.IsyncMoneyRet} message syncMoneyRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncMoneyRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.errorCode != null && Object.hasOwnProperty.call(message, "errorCode"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.errorCode);
                return writer;
            };

            /**
             * Encodes the specified syncMoneyRet message, length delimited. Does not implicitly {@link msg.action.syncMoneyRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {msg.action.IsyncMoneyRet} message syncMoneyRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncMoneyRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a syncMoneyRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.syncMoneyRet} syncMoneyRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncMoneyRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.syncMoneyRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.errorCode = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a syncMoneyRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.syncMoneyRet} syncMoneyRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncMoneyRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a syncMoneyRet message.
             * @function verify
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            syncMoneyRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.errorCode != null && message.hasOwnProperty("errorCode"))
                    if (!$util.isInteger(message.errorCode))
                        return "errorCode: integer expected";
                return null;
            };

            /**
             * Creates a syncMoneyRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.syncMoneyRet} syncMoneyRet
             */
            syncMoneyRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.syncMoneyRet)
                    return object;
                var message = new $root.msg.action.syncMoneyRet();
                if (object.errorCode != null)
                    message.errorCode = object.errorCode | 0;
                return message;
            };

            /**
             * Creates a plain object from a syncMoneyRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.syncMoneyRet
             * @static
             * @param {msg.action.syncMoneyRet} message syncMoneyRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            syncMoneyRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults)
                    object.errorCode = 0;
                if (message.errorCode != null && message.hasOwnProperty("errorCode"))
                    object.errorCode = message.errorCode;
                return object;
            };

            /**
             * Converts this syncMoneyRet to JSON.
             * @function toJSON
             * @memberof msg.action.syncMoneyRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            syncMoneyRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return syncMoneyRet;
        })();

        action.passReq = (function() {

            /**
             * Properties of a passReq.
             * @memberof msg.action
             * @interface IpassReq
             * @property {number|null} [passNum] passReq passNum
             */

            /**
             * Constructs a new passReq.
             * @memberof msg.action
             * @classdesc Represents a passReq.
             * @implements IpassReq
             * @constructor
             * @param {msg.action.IpassReq=} [properties] Properties to set
             */
            function passReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * passReq passNum.
             * @member {number} passNum
             * @memberof msg.action.passReq
             * @instance
             */
            passReq.prototype.passNum = 0;

            /**
             * Creates a new passReq instance using the specified properties.
             * @function create
             * @memberof msg.action.passReq
             * @static
             * @param {msg.action.IpassReq=} [properties] Properties to set
             * @returns {msg.action.passReq} passReq instance
             */
            passReq.create = function create(properties) {
                return new passReq(properties);
            };

            /**
             * Encodes the specified passReq message. Does not implicitly {@link msg.action.passReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.passReq
             * @static
             * @param {msg.action.IpassReq} message passReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            passReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.passNum != null && Object.hasOwnProperty.call(message, "passNum"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.passNum);
                return writer;
            };

            /**
             * Encodes the specified passReq message, length delimited. Does not implicitly {@link msg.action.passReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.passReq
             * @static
             * @param {msg.action.IpassReq} message passReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            passReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a passReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.passReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.passReq} passReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            passReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.passReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.passNum = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a passReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.passReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.passReq} passReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            passReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a passReq message.
             * @function verify
             * @memberof msg.action.passReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            passReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.passNum != null && message.hasOwnProperty("passNum"))
                    if (!$util.isInteger(message.passNum))
                        return "passNum: integer expected";
                return null;
            };

            /**
             * Creates a passReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.passReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.passReq} passReq
             */
            passReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.passReq)
                    return object;
                var message = new $root.msg.action.passReq();
                if (object.passNum != null)
                    message.passNum = object.passNum | 0;
                return message;
            };

            /**
             * Creates a plain object from a passReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.passReq
             * @static
             * @param {msg.action.passReq} message passReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            passReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults)
                    object.passNum = 0;
                if (message.passNum != null && message.hasOwnProperty("passNum"))
                    object.passNum = message.passNum;
                return object;
            };

            /**
             * Converts this passReq to JSON.
             * @function toJSON
             * @memberof msg.action.passReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            passReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return passReq;
        })();

        action.moneyAddRet = (function() {

            /**
             * Properties of a moneyAddRet.
             * @memberof msg.action
             * @interface ImoneyAddRet
             * @property {string|null} [addMoney] moneyAddRet addMoney
             * @property {string|null} [addPhysicalCapacity] moneyAddRet addPhysicalCapacity
             * @property {number|null} [countdown] moneyAddRet countdown
             */

            /**
             * Constructs a new moneyAddRet.
             * @memberof msg.action
             * @classdesc Represents a moneyAddRet.
             * @implements ImoneyAddRet
             * @constructor
             * @param {msg.action.ImoneyAddRet=} [properties] Properties to set
             */
            function moneyAddRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * moneyAddRet addMoney.
             * @member {string} addMoney
             * @memberof msg.action.moneyAddRet
             * @instance
             */
            moneyAddRet.prototype.addMoney = "";

            /**
             * moneyAddRet addPhysicalCapacity.
             * @member {string} addPhysicalCapacity
             * @memberof msg.action.moneyAddRet
             * @instance
             */
            moneyAddRet.prototype.addPhysicalCapacity = "";

            /**
             * moneyAddRet countdown.
             * @member {number} countdown
             * @memberof msg.action.moneyAddRet
             * @instance
             */
            moneyAddRet.prototype.countdown = 0;

            /**
             * Creates a new moneyAddRet instance using the specified properties.
             * @function create
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {msg.action.ImoneyAddRet=} [properties] Properties to set
             * @returns {msg.action.moneyAddRet} moneyAddRet instance
             */
            moneyAddRet.create = function create(properties) {
                return new moneyAddRet(properties);
            };

            /**
             * Encodes the specified moneyAddRet message. Does not implicitly {@link msg.action.moneyAddRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {msg.action.ImoneyAddRet} message moneyAddRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            moneyAddRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.addMoney != null && Object.hasOwnProperty.call(message, "addMoney"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.addMoney);
                if (message.addPhysicalCapacity != null && Object.hasOwnProperty.call(message, "addPhysicalCapacity"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.addPhysicalCapacity);
                if (message.countdown != null && Object.hasOwnProperty.call(message, "countdown"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.countdown);
                return writer;
            };

            /**
             * Encodes the specified moneyAddRet message, length delimited. Does not implicitly {@link msg.action.moneyAddRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {msg.action.ImoneyAddRet} message moneyAddRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            moneyAddRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a moneyAddRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.moneyAddRet} moneyAddRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            moneyAddRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.moneyAddRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.addMoney = reader.string();
                        break;
                    case 2:
                        message.addPhysicalCapacity = reader.string();
                        break;
                    case 3:
                        message.countdown = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a moneyAddRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.moneyAddRet} moneyAddRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            moneyAddRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a moneyAddRet message.
             * @function verify
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            moneyAddRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.addMoney != null && message.hasOwnProperty("addMoney"))
                    if (!$util.isString(message.addMoney))
                        return "addMoney: string expected";
                if (message.addPhysicalCapacity != null && message.hasOwnProperty("addPhysicalCapacity"))
                    if (!$util.isString(message.addPhysicalCapacity))
                        return "addPhysicalCapacity: string expected";
                if (message.countdown != null && message.hasOwnProperty("countdown"))
                    if (!$util.isInteger(message.countdown))
                        return "countdown: integer expected";
                return null;
            };

            /**
             * Creates a moneyAddRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.moneyAddRet} moneyAddRet
             */
            moneyAddRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.moneyAddRet)
                    return object;
                var message = new $root.msg.action.moneyAddRet();
                if (object.addMoney != null)
                    message.addMoney = String(object.addMoney);
                if (object.addPhysicalCapacity != null)
                    message.addPhysicalCapacity = String(object.addPhysicalCapacity);
                if (object.countdown != null)
                    message.countdown = object.countdown | 0;
                return message;
            };

            /**
             * Creates a plain object from a moneyAddRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.moneyAddRet
             * @static
             * @param {msg.action.moneyAddRet} message moneyAddRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            moneyAddRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.addMoney = "";
                    object.addPhysicalCapacity = "";
                    object.countdown = 0;
                }
                if (message.addMoney != null && message.hasOwnProperty("addMoney"))
                    object.addMoney = message.addMoney;
                if (message.addPhysicalCapacity != null && message.hasOwnProperty("addPhysicalCapacity"))
                    object.addPhysicalCapacity = message.addPhysicalCapacity;
                if (message.countdown != null && message.hasOwnProperty("countdown"))
                    object.countdown = message.countdown;
                return object;
            };

            /**
             * Converts this moneyAddRet to JSON.
             * @function toJSON
             * @memberof msg.action.moneyAddRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            moneyAddRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return moneyAddRet;
        })();

        action.syncPetMagicReq = (function() {

            /**
             * Properties of a syncPetMagicReq.
             * @memberof msg.action
             * @interface IsyncPetMagicReq
             * @property {string|null} [physicalCapacity] syncPetMagicReq physicalCapacity
             * @property {Object.<string,msg.action.IHole>|null} [upMap] syncPetMagicReq upMap
             * @property {number|null} [compoundTimes] syncPetMagicReq compoundTimes
             * @property {number|null} [killMonNum] syncPetMagicReq killMonNum
             */

            /**
             * Constructs a new syncPetMagicReq.
             * @memberof msg.action
             * @classdesc Represents a syncPetMagicReq.
             * @implements IsyncPetMagicReq
             * @constructor
             * @param {msg.action.IsyncPetMagicReq=} [properties] Properties to set
             */
            function syncPetMagicReq(properties) {
                this.upMap = {};
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * syncPetMagicReq physicalCapacity.
             * @member {string} physicalCapacity
             * @memberof msg.action.syncPetMagicReq
             * @instance
             */
            syncPetMagicReq.prototype.physicalCapacity = "";

            /**
             * syncPetMagicReq upMap.
             * @member {Object.<string,msg.action.IHole>} upMap
             * @memberof msg.action.syncPetMagicReq
             * @instance
             */
            syncPetMagicReq.prototype.upMap = $util.emptyObject;

            /**
             * syncPetMagicReq compoundTimes.
             * @member {number} compoundTimes
             * @memberof msg.action.syncPetMagicReq
             * @instance
             */
            syncPetMagicReq.prototype.compoundTimes = 0;

            /**
             * syncPetMagicReq killMonNum.
             * @member {number} killMonNum
             * @memberof msg.action.syncPetMagicReq
             * @instance
             */
            syncPetMagicReq.prototype.killMonNum = 0;

            /**
             * Creates a new syncPetMagicReq instance using the specified properties.
             * @function create
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {msg.action.IsyncPetMagicReq=} [properties] Properties to set
             * @returns {msg.action.syncPetMagicReq} syncPetMagicReq instance
             */
            syncPetMagicReq.create = function create(properties) {
                return new syncPetMagicReq(properties);
            };

            /**
             * Encodes the specified syncPetMagicReq message. Does not implicitly {@link msg.action.syncPetMagicReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {msg.action.IsyncPetMagicReq} message syncPetMagicReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncPetMagicReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.physicalCapacity != null && Object.hasOwnProperty.call(message, "physicalCapacity"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.physicalCapacity);
                if (message.upMap != null && Object.hasOwnProperty.call(message, "upMap"))
                    for (var keys = Object.keys(message.upMap), i = 0; i < keys.length; ++i) {
                        writer.uint32(/* id 2, wireType 2 =*/18).fork().uint32(/* id 1, wireType 0 =*/8).int32(keys[i]);
                        $root.msg.action.Hole.encode(message.upMap[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim().ldelim();
                    }
                if (message.compoundTimes != null && Object.hasOwnProperty.call(message, "compoundTimes"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.compoundTimes);
                if (message.killMonNum != null && Object.hasOwnProperty.call(message, "killMonNum"))
                    writer.uint32(/* id 4, wireType 0 =*/32).int32(message.killMonNum);
                return writer;
            };

            /**
             * Encodes the specified syncPetMagicReq message, length delimited. Does not implicitly {@link msg.action.syncPetMagicReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {msg.action.IsyncPetMagicReq} message syncPetMagicReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            syncPetMagicReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a syncPetMagicReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.syncPetMagicReq} syncPetMagicReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncPetMagicReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.syncPetMagicReq(), key, value;
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.physicalCapacity = reader.string();
                        break;
                    case 2:
                        if (message.upMap === $util.emptyObject)
                            message.upMap = {};
                        var end2 = reader.uint32() + reader.pos;
                        key = 0;
                        value = null;
                        while (reader.pos < end2) {
                            var tag2 = reader.uint32();
                            switch (tag2 >>> 3) {
                            case 1:
                                key = reader.int32();
                                break;
                            case 2:
                                value = $root.msg.action.Hole.decode(reader, reader.uint32());
                                break;
                            default:
                                reader.skipType(tag2 & 7);
                                break;
                            }
                        }
                        message.upMap[key] = value;
                        break;
                    case 3:
                        message.compoundTimes = reader.int32();
                        break;
                    case 4:
                        message.killMonNum = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a syncPetMagicReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.syncPetMagicReq} syncPetMagicReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            syncPetMagicReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a syncPetMagicReq message.
             * @function verify
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            syncPetMagicReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.physicalCapacity != null && message.hasOwnProperty("physicalCapacity"))
                    if (!$util.isString(message.physicalCapacity))
                        return "physicalCapacity: string expected";
                if (message.upMap != null && message.hasOwnProperty("upMap")) {
                    if (!$util.isObject(message.upMap))
                        return "upMap: object expected";
                    var key = Object.keys(message.upMap);
                    for (var i = 0; i < key.length; ++i) {
                        if (!$util.key32Re.test(key[i]))
                            return "upMap: integer key{k:int32} expected";
                        {
                            var error = $root.msg.action.Hole.verify(message.upMap[key[i]]);
                            if (error)
                                return "upMap." + error;
                        }
                    }
                }
                if (message.compoundTimes != null && message.hasOwnProperty("compoundTimes"))
                    if (!$util.isInteger(message.compoundTimes))
                        return "compoundTimes: integer expected";
                if (message.killMonNum != null && message.hasOwnProperty("killMonNum"))
                    if (!$util.isInteger(message.killMonNum))
                        return "killMonNum: integer expected";
                return null;
            };

            /**
             * Creates a syncPetMagicReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.syncPetMagicReq} syncPetMagicReq
             */
            syncPetMagicReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.syncPetMagicReq)
                    return object;
                var message = new $root.msg.action.syncPetMagicReq();
                if (object.physicalCapacity != null)
                    message.physicalCapacity = String(object.physicalCapacity);
                if (object.upMap) {
                    if (typeof object.upMap !== "object")
                        throw TypeError(".msg.action.syncPetMagicReq.upMap: object expected");
                    message.upMap = {};
                    for (var keys = Object.keys(object.upMap), i = 0; i < keys.length; ++i) {
                        if (typeof object.upMap[keys[i]] !== "object")
                            throw TypeError(".msg.action.syncPetMagicReq.upMap: object expected");
                        message.upMap[keys[i]] = $root.msg.action.Hole.fromObject(object.upMap[keys[i]]);
                    }
                }
                if (object.compoundTimes != null)
                    message.compoundTimes = object.compoundTimes | 0;
                if (object.killMonNum != null)
                    message.killMonNum = object.killMonNum | 0;
                return message;
            };

            /**
             * Creates a plain object from a syncPetMagicReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.syncPetMagicReq
             * @static
             * @param {msg.action.syncPetMagicReq} message syncPetMagicReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            syncPetMagicReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.objects || options.defaults)
                    object.upMap = {};
                if (options.defaults) {
                    object.physicalCapacity = "";
                    object.compoundTimes = 0;
                    object.killMonNum = 0;
                }
                if (message.physicalCapacity != null && message.hasOwnProperty("physicalCapacity"))
                    object.physicalCapacity = message.physicalCapacity;
                var keys2;
                if (message.upMap && (keys2 = Object.keys(message.upMap)).length) {
                    object.upMap = {};
                    for (var j = 0; j < keys2.length; ++j)
                        object.upMap[keys2[j]] = $root.msg.action.Hole.toObject(message.upMap[keys2[j]], options);
                }
                if (message.compoundTimes != null && message.hasOwnProperty("compoundTimes"))
                    object.compoundTimes = message.compoundTimes;
                if (message.killMonNum != null && message.hasOwnProperty("killMonNum"))
                    object.killMonNum = message.killMonNum;
                return object;
            };

            /**
             * Converts this syncPetMagicReq to JSON.
             * @function toJSON
             * @memberof msg.action.syncPetMagicReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            syncPetMagicReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return syncPetMagicReq;
        })();

        action.petMagicListRet = (function() {

            /**
             * Properties of a petMagicListRet.
             * @memberof msg.action
             * @interface IpetMagicListRet
             * @property {Object.<string,msg.action.IHole>|null} [upMap] petMagicListRet upMap
             */

            /**
             * Constructs a new petMagicListRet.
             * @memberof msg.action
             * @classdesc Represents a petMagicListRet.
             * @implements IpetMagicListRet
             * @constructor
             * @param {msg.action.IpetMagicListRet=} [properties] Properties to set
             */
            function petMagicListRet(properties) {
                this.upMap = {};
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * petMagicListRet upMap.
             * @member {Object.<string,msg.action.IHole>} upMap
             * @memberof msg.action.petMagicListRet
             * @instance
             */
            petMagicListRet.prototype.upMap = $util.emptyObject;

            /**
             * Creates a new petMagicListRet instance using the specified properties.
             * @function create
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {msg.action.IpetMagicListRet=} [properties] Properties to set
             * @returns {msg.action.petMagicListRet} petMagicListRet instance
             */
            petMagicListRet.create = function create(properties) {
                return new petMagicListRet(properties);
            };

            /**
             * Encodes the specified petMagicListRet message. Does not implicitly {@link msg.action.petMagicListRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {msg.action.IpetMagicListRet} message petMagicListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            petMagicListRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.upMap != null && Object.hasOwnProperty.call(message, "upMap"))
                    for (var keys = Object.keys(message.upMap), i = 0; i < keys.length; ++i) {
                        writer.uint32(/* id 2, wireType 2 =*/18).fork().uint32(/* id 1, wireType 0 =*/8).int32(keys[i]);
                        $root.msg.action.Hole.encode(message.upMap[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim().ldelim();
                    }
                return writer;
            };

            /**
             * Encodes the specified petMagicListRet message, length delimited. Does not implicitly {@link msg.action.petMagicListRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {msg.action.IpetMagicListRet} message petMagicListRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            petMagicListRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a petMagicListRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.petMagicListRet} petMagicListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            petMagicListRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.petMagicListRet(), key, value;
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 2:
                        if (message.upMap === $util.emptyObject)
                            message.upMap = {};
                        var end2 = reader.uint32() + reader.pos;
                        key = 0;
                        value = null;
                        while (reader.pos < end2) {
                            var tag2 = reader.uint32();
                            switch (tag2 >>> 3) {
                            case 1:
                                key = reader.int32();
                                break;
                            case 2:
                                value = $root.msg.action.Hole.decode(reader, reader.uint32());
                                break;
                            default:
                                reader.skipType(tag2 & 7);
                                break;
                            }
                        }
                        message.upMap[key] = value;
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a petMagicListRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.petMagicListRet} petMagicListRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            petMagicListRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a petMagicListRet message.
             * @function verify
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            petMagicListRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.upMap != null && message.hasOwnProperty("upMap")) {
                    if (!$util.isObject(message.upMap))
                        return "upMap: object expected";
                    var key = Object.keys(message.upMap);
                    for (var i = 0; i < key.length; ++i) {
                        if (!$util.key32Re.test(key[i]))
                            return "upMap: integer key{k:int32} expected";
                        {
                            var error = $root.msg.action.Hole.verify(message.upMap[key[i]]);
                            if (error)
                                return "upMap." + error;
                        }
                    }
                }
                return null;
            };

            /**
             * Creates a petMagicListRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.petMagicListRet} petMagicListRet
             */
            petMagicListRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.petMagicListRet)
                    return object;
                var message = new $root.msg.action.petMagicListRet();
                if (object.upMap) {
                    if (typeof object.upMap !== "object")
                        throw TypeError(".msg.action.petMagicListRet.upMap: object expected");
                    message.upMap = {};
                    for (var keys = Object.keys(object.upMap), i = 0; i < keys.length; ++i) {
                        if (typeof object.upMap[keys[i]] !== "object")
                            throw TypeError(".msg.action.petMagicListRet.upMap: object expected");
                        message.upMap[keys[i]] = $root.msg.action.Hole.fromObject(object.upMap[keys[i]]);
                    }
                }
                return message;
            };

            /**
             * Creates a plain object from a petMagicListRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.petMagicListRet
             * @static
             * @param {msg.action.petMagicListRet} message petMagicListRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            petMagicListRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.objects || options.defaults)
                    object.upMap = {};
                var keys2;
                if (message.upMap && (keys2 = Object.keys(message.upMap)).length) {
                    object.upMap = {};
                    for (var j = 0; j < keys2.length; ++j)
                        object.upMap[keys2[j]] = $root.msg.action.Hole.toObject(message.upMap[keys2[j]], options);
                }
                return object;
            };

            /**
             * Converts this petMagicListRet to JSON.
             * @function toJSON
             * @memberof msg.action.petMagicListRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            petMagicListRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return petMagicListRet;
        })();

        action.recycleLevelReq = (function() {

            /**
             * Properties of a recycleLevelReq.
             * @memberof msg.action
             * @interface IrecycleLevelReq
             * @property {string|null} [towerId] recycleLevelReq towerId
             * @property {number|null} [level] recycleLevelReq level
             */

            /**
             * Constructs a new recycleLevelReq.
             * @memberof msg.action
             * @classdesc Represents a recycleLevelReq.
             * @implements IrecycleLevelReq
             * @constructor
             * @param {msg.action.IrecycleLevelReq=} [properties] Properties to set
             */
            function recycleLevelReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * recycleLevelReq towerId.
             * @member {string} towerId
             * @memberof msg.action.recycleLevelReq
             * @instance
             */
            recycleLevelReq.prototype.towerId = "";

            /**
             * recycleLevelReq level.
             * @member {number} level
             * @memberof msg.action.recycleLevelReq
             * @instance
             */
            recycleLevelReq.prototype.level = 0;

            /**
             * Creates a new recycleLevelReq instance using the specified properties.
             * @function create
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {msg.action.IrecycleLevelReq=} [properties] Properties to set
             * @returns {msg.action.recycleLevelReq} recycleLevelReq instance
             */
            recycleLevelReq.create = function create(properties) {
                return new recycleLevelReq(properties);
            };

            /**
             * Encodes the specified recycleLevelReq message. Does not implicitly {@link msg.action.recycleLevelReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {msg.action.IrecycleLevelReq} message recycleLevelReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            recycleLevelReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.towerId != null && Object.hasOwnProperty.call(message, "towerId"))
                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.towerId);
                if (message.level != null && Object.hasOwnProperty.call(message, "level"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.level);
                return writer;
            };

            /**
             * Encodes the specified recycleLevelReq message, length delimited. Does not implicitly {@link msg.action.recycleLevelReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {msg.action.IrecycleLevelReq} message recycleLevelReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            recycleLevelReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a recycleLevelReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.recycleLevelReq} recycleLevelReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            recycleLevelReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.recycleLevelReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.towerId = reader.string();
                        break;
                    case 2:
                        message.level = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a recycleLevelReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.recycleLevelReq} recycleLevelReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            recycleLevelReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a recycleLevelReq message.
             * @function verify
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            recycleLevelReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.towerId != null && message.hasOwnProperty("towerId"))
                    if (!$util.isString(message.towerId))
                        return "towerId: string expected";
                if (message.level != null && message.hasOwnProperty("level"))
                    if (!$util.isInteger(message.level))
                        return "level: integer expected";
                return null;
            };

            /**
             * Creates a recycleLevelReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.recycleLevelReq} recycleLevelReq
             */
            recycleLevelReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.recycleLevelReq)
                    return object;
                var message = new $root.msg.action.recycleLevelReq();
                if (object.towerId != null)
                    message.towerId = String(object.towerId);
                if (object.level != null)
                    message.level = object.level | 0;
                return message;
            };

            /**
             * Creates a plain object from a recycleLevelReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.recycleLevelReq
             * @static
             * @param {msg.action.recycleLevelReq} message recycleLevelReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            recycleLevelReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.towerId = "";
                    object.level = 0;
                }
                if (message.towerId != null && message.hasOwnProperty("towerId"))
                    object.towerId = message.towerId;
                if (message.level != null && message.hasOwnProperty("level"))
                    object.level = message.level;
                return object;
            };

            /**
             * Converts this recycleLevelReq to JSON.
             * @function toJSON
             * @memberof msg.action.recycleLevelReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            recycleLevelReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return recycleLevelReq;
        })();

        action.Hole = (function() {

            /**
             * Properties of a Hole.
             * @memberof msg.action
             * @interface IHole
             * @property {number|null} [pos] Hole pos
             * @property {string|null} [towerId] Hole towerId
             * @property {number|null} [level] Hole level
             */

            /**
             * Constructs a new Hole.
             * @memberof msg.action
             * @classdesc Represents a Hole.
             * @implements IHole
             * @constructor
             * @param {msg.action.IHole=} [properties] Properties to set
             */
            function Hole(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * Hole pos.
             * @member {number} pos
             * @memberof msg.action.Hole
             * @instance
             */
            Hole.prototype.pos = 0;

            /**
             * Hole towerId.
             * @member {string} towerId
             * @memberof msg.action.Hole
             * @instance
             */
            Hole.prototype.towerId = "";

            /**
             * Hole level.
             * @member {number} level
             * @memberof msg.action.Hole
             * @instance
             */
            Hole.prototype.level = 0;

            /**
             * Creates a new Hole instance using the specified properties.
             * @function create
             * @memberof msg.action.Hole
             * @static
             * @param {msg.action.IHole=} [properties] Properties to set
             * @returns {msg.action.Hole} Hole instance
             */
            Hole.create = function create(properties) {
                return new Hole(properties);
            };

            /**
             * Encodes the specified Hole message. Does not implicitly {@link msg.action.Hole.verify|verify} messages.
             * @function encode
             * @memberof msg.action.Hole
             * @static
             * @param {msg.action.IHole} message Hole message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Hole.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.pos != null && Object.hasOwnProperty.call(message, "pos"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.pos);
                if (message.towerId != null && Object.hasOwnProperty.call(message, "towerId"))
                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.towerId);
                if (message.level != null && Object.hasOwnProperty.call(message, "level"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.level);
                return writer;
            };

            /**
             * Encodes the specified Hole message, length delimited. Does not implicitly {@link msg.action.Hole.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.Hole
             * @static
             * @param {msg.action.IHole} message Hole message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            Hole.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a Hole message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.Hole
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.Hole} Hole
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Hole.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.Hole();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.pos = reader.int32();
                        break;
                    case 2:
                        message.towerId = reader.string();
                        break;
                    case 3:
                        message.level = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a Hole message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.Hole
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.Hole} Hole
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            Hole.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a Hole message.
             * @function verify
             * @memberof msg.action.Hole
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            Hole.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.pos != null && message.hasOwnProperty("pos"))
                    if (!$util.isInteger(message.pos))
                        return "pos: integer expected";
                if (message.towerId != null && message.hasOwnProperty("towerId"))
                    if (!$util.isString(message.towerId))
                        return "towerId: string expected";
                if (message.level != null && message.hasOwnProperty("level"))
                    if (!$util.isInteger(message.level))
                        return "level: integer expected";
                return null;
            };

            /**
             * Creates a Hole message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.Hole
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.Hole} Hole
             */
            Hole.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.Hole)
                    return object;
                var message = new $root.msg.action.Hole();
                if (object.pos != null)
                    message.pos = object.pos | 0;
                if (object.towerId != null)
                    message.towerId = String(object.towerId);
                if (object.level != null)
                    message.level = object.level | 0;
                return message;
            };

            /**
             * Creates a plain object from a Hole message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.Hole
             * @static
             * @param {msg.action.Hole} message Hole
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            Hole.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.pos = 0;
                    object.towerId = "";
                    object.level = 0;
                }
                if (message.pos != null && message.hasOwnProperty("pos"))
                    object.pos = message.pos;
                if (message.towerId != null && message.hasOwnProperty("towerId"))
                    object.towerId = message.towerId;
                if (message.level != null && message.hasOwnProperty("level"))
                    object.level = message.level;
                return object;
            };

            /**
             * Converts this Hole to JSON.
             * @function toJSON
             * @memberof msg.action.Hole
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            Hole.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return Hole;
        })();

        action.activePetMagicRet = (function() {

            /**
             * Properties of an activePetMagicRet.
             * @memberof msg.action
             * @interface IactivePetMagicRet
             * @property {number|null} [type] activePetMagicRet type
             * @property {number|null} [id] activePetMagicRet id
             * @property {number|null} [level] activePetMagicRet level
             */

            /**
             * Constructs a new activePetMagicRet.
             * @memberof msg.action
             * @classdesc Represents an activePetMagicRet.
             * @implements IactivePetMagicRet
             * @constructor
             * @param {msg.action.IactivePetMagicRet=} [properties] Properties to set
             */
            function activePetMagicRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * activePetMagicRet type.
             * @member {number} type
             * @memberof msg.action.activePetMagicRet
             * @instance
             */
            activePetMagicRet.prototype.type = 0;

            /**
             * activePetMagicRet id.
             * @member {number} id
             * @memberof msg.action.activePetMagicRet
             * @instance
             */
            activePetMagicRet.prototype.id = 0;

            /**
             * activePetMagicRet level.
             * @member {number} level
             * @memberof msg.action.activePetMagicRet
             * @instance
             */
            activePetMagicRet.prototype.level = 0;

            /**
             * Creates a new activePetMagicRet instance using the specified properties.
             * @function create
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {msg.action.IactivePetMagicRet=} [properties] Properties to set
             * @returns {msg.action.activePetMagicRet} activePetMagicRet instance
             */
            activePetMagicRet.create = function create(properties) {
                return new activePetMagicRet(properties);
            };

            /**
             * Encodes the specified activePetMagicRet message. Does not implicitly {@link msg.action.activePetMagicRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {msg.action.IactivePetMagicRet} message activePetMagicRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            activePetMagicRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.id != null && Object.hasOwnProperty.call(message, "id"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.id);
                if (message.level != null && Object.hasOwnProperty.call(message, "level"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.level);
                return writer;
            };

            /**
             * Encodes the specified activePetMagicRet message, length delimited. Does not implicitly {@link msg.action.activePetMagicRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {msg.action.IactivePetMagicRet} message activePetMagicRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            activePetMagicRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes an activePetMagicRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.activePetMagicRet} activePetMagicRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            activePetMagicRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.activePetMagicRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.id = reader.int32();
                        break;
                    case 3:
                        message.level = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes an activePetMagicRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.activePetMagicRet} activePetMagicRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            activePetMagicRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies an activePetMagicRet message.
             * @function verify
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            activePetMagicRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.id != null && message.hasOwnProperty("id"))
                    if (!$util.isInteger(message.id))
                        return "id: integer expected";
                if (message.level != null && message.hasOwnProperty("level"))
                    if (!$util.isInteger(message.level))
                        return "level: integer expected";
                return null;
            };

            /**
             * Creates an activePetMagicRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.activePetMagicRet} activePetMagicRet
             */
            activePetMagicRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.activePetMagicRet)
                    return object;
                var message = new $root.msg.action.activePetMagicRet();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.id != null)
                    message.id = object.id | 0;
                if (object.level != null)
                    message.level = object.level | 0;
                return message;
            };

            /**
             * Creates a plain object from an activePetMagicRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.activePetMagicRet
             * @static
             * @param {msg.action.activePetMagicRet} message activePetMagicRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            activePetMagicRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.id = 0;
                    object.level = 0;
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.id != null && message.hasOwnProperty("id"))
                    object.id = message.id;
                if (message.level != null && message.hasOwnProperty("level"))
                    object.level = message.level;
                return object;
            };

            /**
             * Converts this activePetMagicRet to JSON.
             * @function toJSON
             * @memberof msg.action.activePetMagicRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            activePetMagicRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return activePetMagicRet;
        })();

        action.getTaskRewardReq = (function() {

            /**
             * Properties of a getTaskRewardReq.
             * @memberof msg.action
             * @interface IgetTaskRewardReq
             * @property {number|null} [taskGroup] getTaskRewardReq taskGroup
             * @property {number|null} [taskId] getTaskRewardReq taskId
             */

            /**
             * Constructs a new getTaskRewardReq.
             * @memberof msg.action
             * @classdesc Represents a getTaskRewardReq.
             * @implements IgetTaskRewardReq
             * @constructor
             * @param {msg.action.IgetTaskRewardReq=} [properties] Properties to set
             */
            function getTaskRewardReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * getTaskRewardReq taskGroup.
             * @member {number} taskGroup
             * @memberof msg.action.getTaskRewardReq
             * @instance
             */
            getTaskRewardReq.prototype.taskGroup = 0;

            /**
             * getTaskRewardReq taskId.
             * @member {number} taskId
             * @memberof msg.action.getTaskRewardReq
             * @instance
             */
            getTaskRewardReq.prototype.taskId = 0;

            /**
             * Creates a new getTaskRewardReq instance using the specified properties.
             * @function create
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {msg.action.IgetTaskRewardReq=} [properties] Properties to set
             * @returns {msg.action.getTaskRewardReq} getTaskRewardReq instance
             */
            getTaskRewardReq.create = function create(properties) {
                return new getTaskRewardReq(properties);
            };

            /**
             * Encodes the specified getTaskRewardReq message. Does not implicitly {@link msg.action.getTaskRewardReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {msg.action.IgetTaskRewardReq} message getTaskRewardReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            getTaskRewardReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.taskGroup != null && Object.hasOwnProperty.call(message, "taskGroup"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.taskGroup);
                if (message.taskId != null && Object.hasOwnProperty.call(message, "taskId"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.taskId);
                return writer;
            };

            /**
             * Encodes the specified getTaskRewardReq message, length delimited. Does not implicitly {@link msg.action.getTaskRewardReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {msg.action.IgetTaskRewardReq} message getTaskRewardReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            getTaskRewardReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a getTaskRewardReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.getTaskRewardReq} getTaskRewardReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            getTaskRewardReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.getTaskRewardReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.taskGroup = reader.int32();
                        break;
                    case 2:
                        message.taskId = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a getTaskRewardReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.getTaskRewardReq} getTaskRewardReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            getTaskRewardReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a getTaskRewardReq message.
             * @function verify
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            getTaskRewardReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.taskGroup != null && message.hasOwnProperty("taskGroup"))
                    if (!$util.isInteger(message.taskGroup))
                        return "taskGroup: integer expected";
                if (message.taskId != null && message.hasOwnProperty("taskId"))
                    if (!$util.isInteger(message.taskId))
                        return "taskId: integer expected";
                return null;
            };

            /**
             * Creates a getTaskRewardReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.getTaskRewardReq} getTaskRewardReq
             */
            getTaskRewardReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.getTaskRewardReq)
                    return object;
                var message = new $root.msg.action.getTaskRewardReq();
                if (object.taskGroup != null)
                    message.taskGroup = object.taskGroup | 0;
                if (object.taskId != null)
                    message.taskId = object.taskId | 0;
                return message;
            };

            /**
             * Creates a plain object from a getTaskRewardReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.getTaskRewardReq
             * @static
             * @param {msg.action.getTaskRewardReq} message getTaskRewardReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            getTaskRewardReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.taskGroup = 0;
                    object.taskId = 0;
                }
                if (message.taskGroup != null && message.hasOwnProperty("taskGroup"))
                    object.taskGroup = message.taskGroup;
                if (message.taskId != null && message.hasOwnProperty("taskId"))
                    object.taskId = message.taskId;
                return object;
            };

            /**
             * Converts this getTaskRewardReq to JSON.
             * @function toJSON
             * @memberof msg.action.getTaskRewardReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            getTaskRewardReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return getTaskRewardReq;
        })();

        action.cashReq = (function() {

            /**
             * Properties of a cashReq.
             * @memberof msg.action
             * @interface IcashReq
             * @property {number|null} [type] cashReq type
             * @property {number|null} [group] cashReq group
             * @property {number|null} [cashGear] cashReq cashGear
             */

            /**
             * Constructs a new cashReq.
             * @memberof msg.action
             * @classdesc Represents a cashReq.
             * @implements IcashReq
             * @constructor
             * @param {msg.action.IcashReq=} [properties] Properties to set
             */
            function cashReq(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * cashReq type.
             * @member {number} type
             * @memberof msg.action.cashReq
             * @instance
             */
            cashReq.prototype.type = 0;

            /**
             * cashReq group.
             * @member {number} group
             * @memberof msg.action.cashReq
             * @instance
             */
            cashReq.prototype.group = 0;

            /**
             * cashReq cashGear.
             * @member {number} cashGear
             * @memberof msg.action.cashReq
             * @instance
             */
            cashReq.prototype.cashGear = 0;

            /**
             * Creates a new cashReq instance using the specified properties.
             * @function create
             * @memberof msg.action.cashReq
             * @static
             * @param {msg.action.IcashReq=} [properties] Properties to set
             * @returns {msg.action.cashReq} cashReq instance
             */
            cashReq.create = function create(properties) {
                return new cashReq(properties);
            };

            /**
             * Encodes the specified cashReq message. Does not implicitly {@link msg.action.cashReq.verify|verify} messages.
             * @function encode
             * @memberof msg.action.cashReq
             * @static
             * @param {msg.action.IcashReq} message cashReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashReq.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.group != null && Object.hasOwnProperty.call(message, "group"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.group);
                if (message.cashGear != null && Object.hasOwnProperty.call(message, "cashGear"))
                    writer.uint32(/* id 3, wireType 0 =*/24).int32(message.cashGear);
                return writer;
            };

            /**
             * Encodes the specified cashReq message, length delimited. Does not implicitly {@link msg.action.cashReq.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.cashReq
             * @static
             * @param {msg.action.IcashReq} message cashReq message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            cashReq.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a cashReq message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.cashReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.cashReq} cashReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashReq.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.cashReq();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.group = reader.int32();
                        break;
                    case 3:
                        message.cashGear = reader.int32();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a cashReq message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.cashReq
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.cashReq} cashReq
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            cashReq.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a cashReq message.
             * @function verify
             * @memberof msg.action.cashReq
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            cashReq.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.group != null && message.hasOwnProperty("group"))
                    if (!$util.isInteger(message.group))
                        return "group: integer expected";
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    if (!$util.isInteger(message.cashGear))
                        return "cashGear: integer expected";
                return null;
            };

            /**
             * Creates a cashReq message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.cashReq
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.cashReq} cashReq
             */
            cashReq.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.cashReq)
                    return object;
                var message = new $root.msg.action.cashReq();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.group != null)
                    message.group = object.group | 0;
                if (object.cashGear != null)
                    message.cashGear = object.cashGear | 0;
                return message;
            };

            /**
             * Creates a plain object from a cashReq message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.cashReq
             * @static
             * @param {msg.action.cashReq} message cashReq
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            cashReq.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.group = 0;
                    object.cashGear = 0;
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.group != null && message.hasOwnProperty("group"))
                    object.group = message.group;
                if (message.cashGear != null && message.hasOwnProperty("cashGear"))
                    object.cashGear = message.cashGear;
                return object;
            };

            /**
             * Converts this cashReq to JSON.
             * @function toJSON
             * @memberof msg.action.cashReq
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            cashReq.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return cashReq;
        })();

        action.raffleResultRet = (function() {

            /**
             * Properties of a raffleResultRet.
             * @memberof msg.action
             * @interface IraffleResultRet
             * @property {number|null} [type] raffleResultRet type
             * @property {number|null} [index] raffleResultRet index
             * @property {string|null} [value] raffleResultRet value
             */

            /**
             * Constructs a new raffleResultRet.
             * @memberof msg.action
             * @classdesc Represents a raffleResultRet.
             * @implements IraffleResultRet
             * @constructor
             * @param {msg.action.IraffleResultRet=} [properties] Properties to set
             */
            function raffleResultRet(properties) {
                if (properties)
                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                        if (properties[keys[i]] != null)
                            this[keys[i]] = properties[keys[i]];
            }

            /**
             * raffleResultRet type.
             * @member {number} type
             * @memberof msg.action.raffleResultRet
             * @instance
             */
            raffleResultRet.prototype.type = 0;

            /**
             * raffleResultRet index.
             * @member {number} index
             * @memberof msg.action.raffleResultRet
             * @instance
             */
            raffleResultRet.prototype.index = 0;

            /**
             * raffleResultRet value.
             * @member {string} value
             * @memberof msg.action.raffleResultRet
             * @instance
             */
            raffleResultRet.prototype.value = "";

            /**
             * Creates a new raffleResultRet instance using the specified properties.
             * @function create
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {msg.action.IraffleResultRet=} [properties] Properties to set
             * @returns {msg.action.raffleResultRet} raffleResultRet instance
             */
            raffleResultRet.create = function create(properties) {
                return new raffleResultRet(properties);
            };

            /**
             * Encodes the specified raffleResultRet message. Does not implicitly {@link msg.action.raffleResultRet.verify|verify} messages.
             * @function encode
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {msg.action.IraffleResultRet} message raffleResultRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            raffleResultRet.encode = function encode(message, writer) {
                if (!writer)
                    writer = $Writer.create();
                if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.type);
                if (message.index != null && Object.hasOwnProperty.call(message, "index"))
                    writer.uint32(/* id 2, wireType 0 =*/16).int32(message.index);
                if (message.value != null && Object.hasOwnProperty.call(message, "value"))
                    writer.uint32(/* id 3, wireType 2 =*/26).string(message.value);
                return writer;
            };

            /**
             * Encodes the specified raffleResultRet message, length delimited. Does not implicitly {@link msg.action.raffleResultRet.verify|verify} messages.
             * @function encodeDelimited
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {msg.action.IraffleResultRet} message raffleResultRet message or plain object to encode
             * @param {$protobuf.Writer} [writer] Writer to encode to
             * @returns {$protobuf.Writer} Writer
             */
            raffleResultRet.encodeDelimited = function encodeDelimited(message, writer) {
                return this.encode(message, writer).ldelim();
            };

            /**
             * Decodes a raffleResultRet message from the specified reader or buffer.
             * @function decode
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @param {number} [length] Message length if known beforehand
             * @returns {msg.action.raffleResultRet} raffleResultRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            raffleResultRet.decode = function decode(reader, length) {
                if (!(reader instanceof $Reader))
                    reader = $Reader.create(reader);
                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.msg.action.raffleResultRet();
                while (reader.pos < end) {
                    var tag = reader.uint32();
                    switch (tag >>> 3) {
                    case 1:
                        message.type = reader.int32();
                        break;
                    case 2:
                        message.index = reader.int32();
                        break;
                    case 3:
                        message.value = reader.string();
                        break;
                    default:
                        reader.skipType(tag & 7);
                        break;
                    }
                }
                return message;
            };

            /**
             * Decodes a raffleResultRet message from the specified reader or buffer, length delimited.
             * @function decodeDelimited
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
             * @returns {msg.action.raffleResultRet} raffleResultRet
             * @throws {Error} If the payload is not a reader or valid buffer
             * @throws {$protobuf.util.ProtocolError} If required fields are missing
             */
            raffleResultRet.decodeDelimited = function decodeDelimited(reader) {
                if (!(reader instanceof $Reader))
                    reader = new $Reader(reader);
                return this.decode(reader, reader.uint32());
            };

            /**
             * Verifies a raffleResultRet message.
             * @function verify
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {Object.<string,*>} message Plain object to verify
             * @returns {string|null} `null` if valid, otherwise the reason why it is not
             */
            raffleResultRet.verify = function verify(message) {
                if (typeof message !== "object" || message === null)
                    return "object expected";
                if (message.type != null && message.hasOwnProperty("type"))
                    if (!$util.isInteger(message.type))
                        return "type: integer expected";
                if (message.index != null && message.hasOwnProperty("index"))
                    if (!$util.isInteger(message.index))
                        return "index: integer expected";
                if (message.value != null && message.hasOwnProperty("value"))
                    if (!$util.isString(message.value))
                        return "value: string expected";
                return null;
            };

            /**
             * Creates a raffleResultRet message from a plain object. Also converts values to their respective internal types.
             * @function fromObject
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {Object.<string,*>} object Plain object
             * @returns {msg.action.raffleResultRet} raffleResultRet
             */
            raffleResultRet.fromObject = function fromObject(object) {
                if (object instanceof $root.msg.action.raffleResultRet)
                    return object;
                var message = new $root.msg.action.raffleResultRet();
                if (object.type != null)
                    message.type = object.type | 0;
                if (object.index != null)
                    message.index = object.index | 0;
                if (object.value != null)
                    message.value = String(object.value);
                return message;
            };

            /**
             * Creates a plain object from a raffleResultRet message. Also converts values to other types if specified.
             * @function toObject
             * @memberof msg.action.raffleResultRet
             * @static
             * @param {msg.action.raffleResultRet} message raffleResultRet
             * @param {$protobuf.IConversionOptions} [options] Conversion options
             * @returns {Object.<string,*>} Plain object
             */
            raffleResultRet.toObject = function toObject(message, options) {
                if (!options)
                    options = {};
                var object = {};
                if (options.defaults) {
                    object.type = 0;
                    object.index = 0;
                    object.value = "";
                }
                if (message.type != null && message.hasOwnProperty("type"))
                    object.type = message.type;
                if (message.index != null && message.hasOwnProperty("index"))
                    object.index = message.index;
                if (message.value != null && message.hasOwnProperty("value"))
                    object.value = message.value;
                return object;
            };

            /**
             * Converts this raffleResultRet to JSON.
             * @function toJSON
             * @memberof msg.action.raffleResultRet
             * @instance
             * @returns {Object.<string,*>} JSON object
             */
            raffleResultRet.prototype.toJSON = function toJSON() {
                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
            };

            return raffleResultRet;
        })();

        return action;
    })();

    return msg;
})();

module.exports = $root;
